---

mstring.cc

Go to the documentation of this file.

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

#ifdef SunOS
#include <sys/varargs.h>
#else
#include <stdarg.h>
#endif

#include "magic/mobject.h"
#include "magic/mstring.h"
#include "magic/mclass.h"
#include "magic/mregexp.h"
#include "magic/mstream.h"
#include "magic/mtextstream.h"
#include "magic/mdatastream.h"
#include "magic/mexception.h"

BEGIN_NAMESPACE (MagiC);

impl_dynamic (String, {Comparable});
    

//                         ----         o                                    //
//                        (      |          _                                //
//                         ---  -+- |/\ | |/ \   ___                         //
//                            )  |  |   | |   | (   \                        //
//                        ___/    \ |   | |   |  ---/                        //
//                                               __/                         //

MagiC::String::String () {
    mLen    = 0;
    mMaxLen = 0;
    mData   = NULL;
    mChkSum = 0;
}

MagiC::String::String (const String& orig   )
{
    if (&orig == NULL || orig.mData==NULL) {
        mLen = 0;
        mMaxLen = 0;
        mData = NULL;
        return;
    }
    mLen = orig.mLen;
    mMaxLen = orig.mMaxLen;
    mData = new char [mMaxLen+1];
    memcpy (mData, orig.mData, mMaxLen+1);
    mChkSum = 0;
}

MagiC::String::String (const char* chrp      )
{
    if (chrp) {
        mLen    = strlen (chrp);
        mMaxLen = mLen;
        mData   = new char [mMaxLen+1];
        memcpy (mData, chrp, mLen+1);
    } else {
        mLen = mMaxLen = 0;
        mData = NULL;
    }
    mChkSum = 0;
}

MagiC::String::String (char* str,            
                       enum strcrflags flags )
{
    if (flags & STRCRFL_OWN)
        mData = str;
    else if (str)
        mData = strdup (str); // TODO
    else
        mData = NULL;

    mLen = mMaxLen = str? strlen (str) : 0;
    mChkSum = 0;
}

MagiC::String::String (const char* chrp,    
                       int n                )
{
    if (chrp && n) {
        mLen    = n;
        mMaxLen = mLen;
        mData   = new char [mMaxLen+1];
        memcpy (mData, chrp, mLen);
        mData [mMaxLen] = 0x00;
    } else {
        mLen = mMaxLen = 0;
        mData = NULL;
    }
    mChkSum = 0;
}

MagiC::String::String (char* str,           
                       uint maxLen,         
                       bool own             )
{
    if (own)
        mData = str;
    else
        mData = strdup (str); // TODO

    mData[maxLen]   = '\0';
    mLen            = str? strlen (str) : 0;
    mMaxLen         = maxLen;
    mChkSum         = 0;
}

MagiC::String::~String () {
    delete mData;
    IFDEBUG (mData = (char*) 0xdddddddd);
}

template<class TYPE>
inline char* intToString(TYPE value, uint base) {
    const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
    if (base > sizeof(digits))
        throw Exception (strformat ("Too large base %d for integer-to-String conversion", base));
    
    const int   maxintlen = 40;
    char        buf[maxintlen];
    char*       loc = buf + (maxintlen-1);
    *(loc--) = '\x00'; // Terminate

    bool isNeg = false; // Remember negative sign
    if (value < 0) {
        isNeg = true;
        value = -value;
    }

    do {
        *(loc--) = digits [value % base];
        value /= base;
    } while (value);

    if (isNeg) // Add sign if negative
        *(loc--) = '-';

    return strdup (loc+1);
}

MagiC::String::String (int i, int base) {
    mData = intToString<int> (i, base);
    mLen = mMaxLen = strlen(mData);
    mChkSum = 0;
}

MagiC::String::String (uint i, int base) {
    mData = intToString<uint> (i, base);
    mLen = mMaxLen = strlen(mData);
    mChkSum = 0;
}

MagiC::String::String (long i, int base) {
    mData = intToString<long> (i, base);
    mLen = mMaxLen = strlen(mData);
    mChkSum = 0;
}

template <class TYPE>
inline char* formatFloat(TYPE f, char fmt, int prec)
{
    // Create formatting string
    char formatBuf [20];
    if (prec >= 0)
        sprintf (formatBuf, "%%.%d%c", prec, fmt);
    else
        sprintf (formatBuf, "%%%c", fmt);

    // Create actual string with the created format
    char buf [80+prec]; // Add prec, because it could be "high".
    sprintf (buf, formatBuf, f);

    return strdup (buf); // TODO: Use safedup
}

MagiC::String::String (float f,     
                       char fmt,    
                       int prec     )
{
    mData = formatFloat<float> (f, fmt, prec);
    mLen = mMaxLen = strlen(mData);
    mChkSum = 0;
}

MagiC::String::String (double f,    
                       char fmt,    
                       int prec     )
{
    mData = formatFloat<double> (f, fmt, prec);
    mLen = mMaxLen = strlen(mData);
    mChkSum = 0;
}

String& MagiC::String::assign (char c)
{
    if (!mData)
        mData = new char [2];
    mData[0] = c;
    mData[1] = '\x00';
    mLen = 1;
    mChkSum = 0;
    return *this;
}

String& MagiC::String::append (char c)
{
    // Ensure that our buffer is large enough
    ensure_spontane (mLen + 1);

    mData[mLen++]   = c;
    mData[mLen]     = '\x00'; // Terminate properly with \0
    mChkSum         = 0;

    return *this;
}

String& MagiC::String::append (const char* str, 
                               uint strlength   )
{
    // Ensure that the string to append is not empty
    if (!str || strlength==0)
        return *this;
    
    // Ensure that our buffer is large enough
    if (mLen + int(strlength) > mMaxLen)
        ensure (mLen + strlength + 1);

    // Copy, but without a trailing \0
    memcpy (mData+mLen, str, strlength);

    mLen        += strlength;
    mData[mLen] =  '\x00'; // Terminate properly with \0
    mChkSum     =  0;

    return *this;
}

String& MagiC::String::replace (uint position,          
                                const char* buffer,     
                                int buflen              )
{
    if (!buffer)
        return *this;
    
    if (buflen < 0)
        buflen = strlen (buffer);

    if ((int) position >= mLen)
        position = mLen;

    ensure_spontane (position + buflen);

    // Replace
    memcpy (mData+position, buffer, buflen);

    if ((int) (position + buflen) > mLen) {
        mLen = position + buflen;
        mData[mLen] = '\x00';
    }

    return *this;
}


String& MagiC::String::operator= (const String& other )
{
    if (&other == NULL || other.mData==NULL || other.mLen==0) {
        // The string was null
        if (mData) {
            mLen    = 0;
            *mData  = '\x00'; // Preserve it
        }
    } else {
        // The string contains something
        mLen = other.mLen;
        if (mLen > mMaxLen) { // Reallocate only if necessary
            if (mData)
                delete mData;
            mMaxLen = mLen;
            mData = new char [mMaxLen+1];
        }
        memcpy (mData, other.mData, mLen+1);
    }
    mChkSum = other.mChkSum;
    return *this;
}

String& MagiC::String::operator= (const char* chrp  )
{
    if (!chrp || !*chrp) {
        // The string was null or empty
        if (mData) {
            mLen    = 0;
            *mData  = '\x00'; // Preserve it
        }
    } else {
        // The string has something
        mLen = strlen (chrp);
        if (mLen > mMaxLen) { // Reallocate only if necessary
            if (mData)
                delete mData;
            mMaxLen = mLen;
            mData = new char [mMaxLen+1];
        }
        memcpy (mData, chrp, mLen+1);
    }
    mChkSum = 0;
    return *this;
}

/*
ostream& MagiC::String::dump (ostream& out) const {
    out << format ("String #0x%x\n");
    out << "mData=" << mData << "\n";
    out << "mLen=" << mLen << "\n";
    out << "mMaxLen=" << mMaxLen << "\n";
    return out;
}
*/

ostream& MagiC::String::operator>> (ostream& out) const
{
    if (mData)
        out << mData;
    else
        out << "(null)";
    return out;
}

/******************************************************************************/
TextOStream& MagiC::String::operator>> (TextOStream& out) const
{
    if (mData)
        out << mData;
    else
        out << "(null)";
    return out;
}

TextIStream& MagiC::String::operator<< (TextIStream& is)
{
    ensure_spontane (80);
    mLen        = 0;
    mData[0]    = '\x00';

    int w = is.width (0);
    IODevice *dev = is.device (); // Read the device directly
    while (1) {
        // Read one character.
        int ch = dev->getch();

        //printf ("[%c]", ch);

        // Terminate string on either EOF or whitespace.
        if (ch == EOF)
            break;
        else if (isspace (ch))
            break;

        (*this) += ch;
        if (--w == 1)
            break;
    }

    if (mLen == 0) {
        // Didn't read anything. This is a problem. NOTE: REALLY????? Uh...
        //dev->setStatus (IO_ReadError);
    }

    return is;
}

/******************************************************************************/
DataOStream& MagiC::String::operator>> (DataOStream& arc) const
{
    arc.name ("mLen") << mLen;
    arc.name ("mMaxLen") << mMaxLen;
    arc.name ("mData").writeRawBytes (mData, mLen? mLen+1 : 0);
    return arc;
}

/******************************************************************************/
DataIStream& MagiC::String::operator<< (DataIStream& arc)
{
    arc >> mLen;
    arc >> mMaxLen;

    ensure (mMaxLen);
    arc.readRawBytes (mData, mLen+1);
    mData[mLen] = '\x00';
    mChkSum=0;
    
    return arc;
}

/******************************************************************************/
String MagiC::String::operator+ (const String& other) const
{
    String result = *this;
    result += other;
    return result;
}

/******************************************************************************/
String MagiC::String::operator+ (const char* str ) const
{
    String result = *this;
    result += String(str);
    return result;
}

/******************************************************************************/
bool findLowestNum (const String& str, uint& start, uint& end)
{
    // Scan the string using a state machine.
    enum states {NORMAL=0, FOUNDPERCENT};
    int state = NORMAL;     // Current state
    int number = 0;         // Number currently being scanned
    int curPos = 0;         // Starting position of the currently scanned number
    int lowest = 999999;    // Lowest number found so far
    start = 0;              // Start position of the lowest number found so far
    end = 0;                // End position of the lowest number found so far

    for (uint i=0; i<str.length(); i++) {
        switch (state) {
          case NORMAL:
              if (str[i] == '%') {
                  state = FOUNDPERCENT;
                  number = 0;
                  curPos = i;
              }
              break;
          case FOUNDPERCENT:
              if (isdigit(str[i]))
                  number = number*10 + int(str[i]-'0');
              else {
                  if (number < lowest) {
                      // Found a new lowest
                      lowest    = number;
                      start     = curPos;
                      end       = i;
                  }
                  state = NORMAL;
              }
              break;
        }
    }
    if (state == FOUNDPERCENT && number < lowest) {
        // Found a new lowest in the end of the string
        start   = curPos;
        end     = str.length();
        lowest  = 0;
    }

    return (lowest!=999999);
}

/******************************************************************************/
String MagiC::String::arg (const String& replacement, int fieldwidth) const {
    uint start, end;
    if (findLowestNum (*this, start, end)) {
        int     realwidth   = (replacement.length() > (uint)fieldwidth)? replacement.length() : fieldwidth;
        int     maxLen      = start + realwidth + (length()-end);
        char*   buf         = new char[maxLen + 1];
        char*   resultPos   = buf;

        // Concatenate beginning of the string, if not in the beginning
        if (start > 0) {
            memcpy (resultPos, mData, start);
            resultPos += start;
        }

        // Concatenate replacement (with padding)
        if (realwidth > 0) {
            for (int padding = (realwidth>fieldwidth)? 0 : fieldwidth-replacement.length(); padding>0; padding--)
                *(resultPos++) = ' ';
            memcpy (resultPos, replacement.mData, replacement.length());
            resultPos += replacement.length();
        }

        // Concatenate rest of the string, if not at end
        if (end < (uint) mLen) {
            memcpy (resultPos, mData+end, mLen-end);
            resultPos += mLen-end;
        }
        *resultPos = '\x00';

        // Create return object using the buffer.
        return String (buf, maxLen, true);
    } else
        // This is an error situation, basicly, but we return something nevertheless.
        return *this;
}

/******************************************************************************/
String& MagiC::String::dellast (uint n)
{
    if (!mData)
        return *this;

    // Delete at most the length of the string
    if (n >= (uint) mLen)
        n = mLen;
    mLen -= n;
    mData[mLen] = 0;
    mChkSum = 0;
    return *this;
}

void MagiC::String::chop ()
{
    while (mLen>0 && isspace(mData[mLen-1]))
        dellast (1);
    mChkSum=0;
}

int MagiC::String::fast_isequal (const String& other) const {
    if (other.mChkSum == mChkSum)
        return operator== (other.mData);
    else
        return 0;
}

String& MagiC::String::hexcode (const String& other) {
    const char hexcodes[] = "0123456789abcdef";
    int otherlen = other.length();
    ensure (otherlen*2);
    for (int i=0; i<otherlen; i++) {
        *this += hexcodes [((unsigned int) other.mData[i])/16];
        *this += hexcodes [((unsigned int) other.mData[i])%16];
    }
    mChkSum=0;
    return *this;
}

void MagiC::String::quote (char quotechar, int flags) {
    FORBIDDEN; // Not implemented
}

void MagiC::String::unquote (char quotechar, int flags) {
    enum    states {Waiting, GotEqual, GotFirst, GotSoftLinebreak};

    String  hextable    = "0123456789ABCDEF";
    int     state       = Waiting;
    int     value       = 0;
    String  tmp;                             // Storage for characters after translation

    tmp.reserve (mLen);

    // Loop through string
    for (uint i=0 ; i < (uint) mLen ; i++) {
        char c = (*this)[i];
        switch (state) {
            case Waiting:
                if (c == quotechar)
                    state=GotEqual;
                else
                    if (c=='+' && (flags&QUOTE_HTML))
                        tmp += ' ';
                    else
                        tmp += c;
                break;
                
            case GotEqual:
                if ((value=hextable.find(c)) != -1) {
                    state=GotFirst;
                    value*=16; // Shiftataan ylöspäin....
                } else { // Hmm, ei ollutkaan heksaluku...
                    if (c=='\r') { // soft CRLF
                        state = GotSoftLinebreak;
                    } else {
                        // Something weird...
                        // Error in Q-P code! Let's recover it...
                        state = Waiting;
                        tmp += quotechar; 
                        tmp += c;
                    }
                }
                break;
                
            case GotFirst:
                if (hextable.find(c) != -1) {
                    value+=hextable.find (c);
                    tmp += char(value);
                    state=Waiting; // Ok, palataan normaaliin tilaan...
                } else {
                    // Jotain omituista, virhe QP-koodista.. yritetään toipua..
                    tmp += quotechar;
                    tmp += char(value);
                    tmp += c;
                    state = Waiting; // Så vi ventar igen..
                }
                break;
                
            case GotSoftLinebreak:
                // Not a soft linebreak after all?
                if (c!='\n')
                    // Try to recover somehow...
                    tmp += c;
                state=Waiting;
                break;
        };
    }

    if (state!= Waiting) {
        // Hmm, siellä oli siis lopussa yksinäinen '=' -> PANIC!
        tmp += '=';
        if (state==GotFirst)
            // DOUBLEPANIC!, mutta varaudutaan silti...
            // Hmm, tätä ei pitäisi tarvita tehdä...
            tmp += char(hextable[uint(state/16)]);
    } // DON'T PANIC!

    // Laitetaan loppunulli
    // tmp += '\x00';
    // tmp.mLen = respos;

    (*this) = tmp;
}

String MagiC::String::mid (uint from, int n) const {
    String result;
    
    // Jos pituus on -1, otetaan loput merkkijonosta
    if (n==-1)
        n = mLen-from;

    // Jos pyydetään merkkijonon ulkopuolelta tai tyhjä jono
    if (from >= (uint) mLen || mLen==0)
        return "";

    // Jos pyyntö menee merkkijonon ulkopuolelle, pienennetään pyyntöä
    if (((from + n) > (uint) mLen))
        n = mLen-from;

    ASSERT (mMaxLen>=n);
    
    // Luodaan uusi merkkijono
    result.mLen = n;
    result.mMaxLen = mMaxLen;
    result.mData = new char [mMaxLen+1];
    strncpy (result.mData, mData+from, n);
    result.mData [n] = 0;

    return result;
}

String MagiC::String::left (uint n) const {
    return mid (0, n);
}

String MagiC::String::right (uint n) const {
    String result;
    
    if (n < (uint) mLen)
        result = mid (mLen-n);
    else
        result = *this;

    return result;
}

int MagiC::String::find (const String& subs, uint n) const {
    for (int i=n; i <= (mLen-subs.mLen); i++)
        if (!strncmp (mData+i, subs.mData, subs.mLen))
            return i;
    return -1;
}

int MagiC::String::find (const char c, uint n) const {
    char* pos = (char*) memchr (mData+n, c, mLen);
    return pos? pos-mData : -1;
}

int MagiC::String::findRev (const String& subs, int n) const {
    if (n<0)
        n += mLen;
    for (int i=n; i>=0; i--)
        if (!strncmp (mData+i, subs.mData, subs.mLen))
            return i;
    return -1;
}

String* MagiC::String::clone () const {
    return new String (*this);
}

int MagiC::String::operator== (const char* other) const {
    if (!this)
        return 0;
    if (mData && other)
        return (!strcmp (mData, other));
    if ((!mData) && (!other))
        return 1;
    return 0;
}

int MagiC::String::operator== (const Comparable& other) const {
    if (getclass().issameclass (other))
        return operator== ((const String&) other);
    else
        return 0;
}

void MagiC::String::reserve (int amount) {
    if (mData) {
        char* newmData = new char [amount+1];
        if (!newmData)
            throw runtime_error ("Out of memory or something in MagiC::String::reserve()");
        memcpy (newmData, mData, mLen+1);
        delete mData;
        mData = newmData;
        mData [amount] = 0x00;
    } else {
        mData = new char[amount+1];
        if (!mData)
            throw runtime_error ("Out of memory or something in MagiC::String::reserve()");
        *mData = 0x00;
    }
    mMaxLen = amount;
}

/*
const char& MagiC::String::operator[] (uint n) const {
    if (n<mLen)
        return mData [n];
    else
        throw Exception ("String index out of bounds");
}
*/

/*
char& MagiC::String::operator[] (uint n) {
    if (n<mLen)
        return mData [n];
    else {
        throw Exception ("String index out of bounds");
        return *mData; // To get rid of a warning
    }
}
*/

void MagiC::String::split (Array<String>& trg, const char delim) const {
    if (!this || !mLen)
        return;

    // Use temporary copy
    char* tmp = new char [mLen+1];
    memcpy (tmp, mData, mLen+1);
    tmp[mLen]=0;

    // Change delimiters to null-characters
    for (int i=0; i<mLen; i++)
        if (tmp[i]==delim)
            tmp[i]=0;

    // Create response
    trg.empty ();
    for (int pos = 0, i=0; pos<mLen; pos+=strlen (tmp+pos)+1, i++) {
        String tmps = tmp+pos;
        trg.put (tmps, i);
    }
    delete tmp;
}

void MagiC::String::join (const Array<String>& src, const char delim) {
    // Lasketaan kohdemerkkijonon pituus tilanvarausta varten
    int newlen = src.size() - 1;
    for (int i=0; i<src.size(); i++)
        newlen += src[i].length();

    // Varataan tila
    reserve (newlen);
    *this = "";

    // Katenoidaan merkkijonot
    for (int i=0; i < src.size(); i++) 
        if (!src[i].isEmpty ()) {
            *this += src[i];
            if (i < src.size() - 1)
                *this += delim;
        }

    mChkSum=0;
}

String MagiC::String::stripWhiteSpace () const {
    uint s=0, e=mLen;
    while (s < (uint) mLen && strchr (" \t\r\n",(*this)[s])) // TODO: Add ff, vt
        s++;
    while (e>s && strchr (" \t\r\n",(*this)[e-1])) // TODO: Add ff, vt
        e--;
    return mid (s, e-s);
}

String MagiC::String::simplifyWhiteSpace () const {
    if (mLen == 0)
        return String();

    char*   buffer  = new char[mLen+1]; // Add 1 for terminating \x00
    char*   trgPos  = buffer;
    int     pos     = 0;

    // Strip whitespace from beginning
    for (pos=0; pos<mLen; pos++)
        if (!isspace(mData[pos]))
            break;

    // Strip duplicate whitespaces
    bool oneWhitespace=false;
    for (; pos<mLen; pos++) {
        if (isspace(mData[pos])) {
            if (!oneWhitespace)
                *(trgPos++) = mData[pos];
            oneWhitespace = true;
        } else {
            *(trgPos++) = mData[pos];
            oneWhitespace = false;
        }
    }

    // Strip whitespace from end (there can be only one)
    if (isspace (*(trgPos-1)))
        trgPos--;
    *trgPos = '\x00';

    if (trgPos > buffer)
        // Construct using the buffer.
        return String (buffer, mLen+1, true);
    else {
        // The string became empty -> return really empty string.
        delete buffer;
        return String ();
    }
}

void MagiC::String::upper() const {
    for (int i=0; i<mLen; i++)
        mData[i] = toupper (mData[i]);
}

void MagiC::String::lower() const {
    for (int i=0; i<mLen; i++)
        mData[i] = tolower (mData[i]);
}

int MagiC::String::regmatch (const char* expr) const {
    if (!mData)
        return 0;
    RegExp rexp (expr);
    return rexp.match (mData);
}

int MagiC::String::regmatch (const char* expr, Array<String>& target) const {
    if (!mData)
        return 0;
    RegExp rexp (expr);
    return rexp.match (*this, target);
}

int MagiC::String::regmatch (RegExp& compiled, Array<String>& target) const {
    if (!mData)
        return 0;
    return compiled.match (*this, target);
}

void MagiC::String::empty ()
{
    if (mData) {
        mLen = 0;
        mData[mLen] = '\x00';
    }
}

char MagiC::String::checksum () {
    mChkSum = 0;
    hashfunc (256);
    return mChkSum;
}

int MagiC::String::hashfunc (int hashsize) const
{
    ASSERTWITH (hashsize<=256, format ("String hash size maximum is 256 slots",
                                       " (hashsize was %d)", hashsize));
    
    // Jos on checksum laskettu, palautetaan sen mukainen arvo
    if (mChkSum)
        return mChkSum % hashsize;

    if (!mLen)
        return 0;

    int sum = 0;
    if (mLen < 10) {
        // Lyhyille merkkijonoille
        
        for (int i=0; i<mLen; i++)
            sum += mData[i];

        (unsigned char&) mChkSum = sum % 256;
    } else {
        // Pitemmille merkkijonoille

        // Sum of the first, middle and last character
        sum = int(mData[0]) + int(mData[mLen/2]) + mLen*int(mData[mLen-1]);

        (unsigned char&) mChkSum = sum % 256;
    }

    // TRACE4 ("%s -> %d/%d/%d", mData, sum, int(mChkSum), int(mChkSum%hashsize));
    return mChkSum % hashsize;
}

/*
MagiC::String::operator float () const {
    if (mData) {
        char* tmp = strdup (mData);
        for (char* tmp_p=tmp; *tmp_p; tmp_p++)
            if (*tmp_p == ',')
                *tmp_p = '.';
        float res = atof (tmp);
        free (tmp);
        return res;
    }
    return 0;
}
*/


//                                     |                              o                  //
//  ___       |   ___        _    ___  |     __         _    ___   |           _    ____ //
// /   ) \ / -+- /   ) |/\ |/ \   ___| |    /   |   | |/ \  |   \ -+- |  __  |/ \  (     //
// |---   X   |  |---  |   |   | (   | |    +-- |   | |   | |      |  | /  \ |   |  \__  //
//  \__  / \   \  \__  |   |   |  \__| |    |    \__! |   |  \__/   \ | \__/ |   | ____) //
//                                          |                                            //

const String MagiC::emptystring;

char* MagiC::strnchr (const char* str, int mLen, char c) {
    const char* pos=str;
    for (int i=0; i<mLen; i++, pos++)
        if (*pos == c)
            return (char*) pos;
    return NULL;
}

char* safedup (const char* orig, int maxlen) {
    if (orig) {
        // Duplicate.
        // We can't use strdup, because ANSI C++ doesn't have it.
        int len = strlen (orig)+1; // Length with end-null.
        char* result = new char [len];
        memcpy (result, orig, len);
        return result;
    } else
        return (char*) NULL;
}

int MagiC::fgetS (FILE* in, String& str) {
    char    cbuff [4097],
            *nlpos;
    int bytesread = 0;
    str = "";

    do {
        // Read a data block to buffer
        char* callResult = fgets (cbuff, 4096, in);

        if (callResult == NULL)
            break;

        // See if the block contains a newline
        nlpos = strnchr (cbuff, 4096, '\n');

        // Calculate the length of the block read
        int blocklength = nlpos? nlpos-cbuff+1 : 4096;

        // Add to result
        str.append (cbuff, blocklength);

        bytesread += blocklength;

        // Toistetaan kunnes löydetään lohkosta rivinvaihto
    } while (!nlpos && !feof (in));

    return bytesread;
}

istream& MagiC::getS    (istream& is, String& str, char term) {
    str = ""; // TODO: This may shorten the maxlen?
    str.ensure_spontane (80);
    
    register streambuf *sb = is.rdbuf ();
    bool eof=false;
    while (true) {
        int ch = sb->sbumpc ();
        if (ch == EOF) {
            eof = true;
            is.setstate (ios::eofbit);
            break;

            // Separation with given character, or whitespace, if
            // the terminator is \xff.
        } else if ((term!='\xff' && ch==term) || (term=='\xff' && isspace (ch)))
            break;
        
        // Skip CR
        else if (term!='\n' || ch!='\r')
            str += char(ch);
    }

    if (eof && str.length()==0)
        is.setstate (ios::failbit);

    return is;
}

void nullcharspace (int charspace [256]) {
    for (int i=0; i<256; i++)
        charspace [i]=0;
}

void MagiC::loadString (String& str, const String& filename) {
    FILE* in = fopen (filename, "rb");
    if (!in)
        return;
    str = "";
    String buff;
    buff.reserve (200);
    while (!feof(in)) {
        fgetS (in, buff);
        str += buff;
    }
    fclose (in);
}

/*****************************************************************************/
String MagiC::strformat (const char* sformat, 
                         ...)                 
{
    va_list args;
    va_start (args, sformat);

    String result = vstrformat (sformat, args);
    
    va_end (args);
    
    return result;
}

/*****************************************************************************/
String MagiC::vstrformat (const char* sformat, 
                          va_list ap)          
{
    // Reserve a smallish buffer
    char* buffer = new char [STRFORMAT_SMALL_BUFFER_SIZE + 1];

    // Try writing to a smallish buffer
    int written = vsnprintf (buffer, STRFORMAT_SMALL_BUFFER_SIZE + 1, sformat, ap);

    if (written > STRFORMAT_SMALL_BUFFER_SIZE) {
        // Grow the buffer to the required size
        delete buffer;
        buffer = new char [written+1];

        // Reprint to the larger buffer
        vsnprintf (buffer, written+1, sformat, ap);
    }

    return String (buffer, String::STRCRFL_OWN);
}

END_NAMESPACE;

---