---

mstring.cc

/***************************************************************************
 *   This file is part of the MagiC++ library.                             *
 *                                                                         *
 *   Copyright (C) 1998-2001 Marko Grönroos <magi@iki.fi>                  *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU Library General Public            *
 *  License as published by the Free Software Foundation; either           *
 *  version 2 of the License, or (at your option) any later version.       *
 *                                                                         *
 *  This library is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
 *  Library General Public License for more details.                       *
 *                                                                         *
 *  You should have received a copy of the GNU Library General Public      *
 *  License along with this library; see the file COPYING.LIB.  If         *
 *  not, write to the Free Software Foundation, Inc., 59 Temple Place      *
 *  - Suite 330, Boston, MA 02111-1307, USA.                               *
 *                                                                         *
 ***************************************************************************/

#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"


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, bool own) {
    mData = str;
    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);
    mData[maxLen] = '\0';
    mLen = str? strlen (str) : 0;
    mMaxLen = maxLen;
    mChkSum = 0;
}

MagiC::String::~String () {
    if (mData) delete mData;
    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::operator= (const String& other) {
    if (&other == NULL || other.mData==NULL || other.mLen==0) {
        // The string was null
        if (mData) {
            mLen    = 0;
            mMaxLen = 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
        if (mData) {
            mLen    = 0;
            mMaxLen = 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 {
    // Observe that mData can be NULL, in which case (null) will be written.
    out << mData;
    return out;
}

istream& MagiC::String::operator<< (istream& is) {
    mLen = 0; // Set size to 0. Warning! Uncommon access!
    if (mData)
        mData[0] = '\x00';
    ensure_spontane (80);
    
    int w = is.width (0);
    if (is.ipfx0 ()) {
        register streambuf *sb = is.rdbuf ();
        while (1) {
            int ch = sb->sbumpc ();
            if (ch == EOF) {
                is.setstate (ios::eofbit);
                break;
            } else if (isspace (ch)) {
                sb->sungetc ();
                break;
            }
            (*this) += ch;
            if (--w == 1)
                break;
        }
    }
    is.isfx ();
    if (mLen == 0) // Didn't read anything. This is a problem. NOTE: REALLY????? Uh...
        is.setstate (ios::failbit);
 
    return is;
}

CArchive& MagiC::String::operator>> (CArchive& arc) const {
    arc.name ("mLen") << mLen;
    arc.name ("mMaxLen") << mMaxLen;
    if (mLen)
        arc.name ("mData").write (mData, mLen+1);
    else
        arc.name ("mData").write (mData, 0);
    return arc;
}

IStream& MagiC::String::operator<< (IStream& arc) {
    arc >> mLen;
    arc >> mMaxLen;
    delete mData;
    mData=NULL;
    mChkSum = 0;
    if (mLen) {
        mData = new char [mMaxLen+1];
        arc.read (mData, mLen+1);
    }
    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 (int 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()>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 < 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>=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=0) {
    FORBIDDEN; // Not implemented
}

void MagiC::String::unquote (char quotechar, int flags) {
    enum    {Waiting, GotEqual, GotFirst, GotSoftLinebreak};
    String  hextable = "0123456789ABCDEF";
    int     state = Waiting,
            value = 0,
            respos = 0;

    // Merkkijono johon merkit käännöksen jälkeen tallennetaan
    // ja kopioidaan tästä lopussa takaisin.
    String tmp;
    tmp.reserve (mLen);

    // Käydään itsemme läpi
    for (int i=0 ; i<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:
                 // Hmm, se ei ollutkaan pehmeä rivinvaihto??
                 if (c!='\n')
                    // no, yritetään toipua jollain lailla....
                    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[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 >= mLen || mLen==0)
        return "";

    // Jos pyyntö menee merkkijonon ulkopuolelle, pienennetään pyyntöä
    if (((from + n) > 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 < 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);
}

String& MagiC::String::operator+= (const String& other) {
    // Varmistutaan ettei toinen ole tyhjä
    if (!other.mLen)
        return *this;

    // Ensure that our buffer is large enough
    if (mLen+other.mLen > mMaxLen)
        ensure (mLen + other.mLen + 1);

    memcpy (mData+mLen, other.mData, other.mLen+1);
    mLen += other.mLen;
    mData[mLen]='\x00';
    mChkSum=0;
    return *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;
}

String& MagiC::String::operator+= (char c) {
    ensure_spontane (mLen+1);
    mData [mLen++] = c;
    mData [mLen] = 0;
    mChkSum=0;
    return *this;
}

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;
    char* tmp = new char [mLen+1];
    memcpy (tmp, mData, mLen+1);
    tmp[mLen]=0;
    for (int i=0; i<mLen; i++)
        if (tmp[i]==delim)
            tmp[i]=0;
    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 {
    int s=0, e=mLen;
    while (s<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);
}

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;

    int sum=0;
    if (!mLen)
        return 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=-1) {
    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 mLen=0;

    str = "";

    do {
        // Luetaan yksi lohko
        fgets (cbuff, 4096, in);

        // Katsotaan onko lohkossa yhtään rivinvaihtoa
        nlpos = strnchr (cbuff, 4096, '\n');

        // Määritellään luetun lohkon pituus
        mLen = nlpos? nlpos-cbuff+1 : 4096;

        // Muunnetaan Stringiksi
        String tmp (cbuff, mLen);

        // Lisätään tulosmerkkijonoon
        str += tmp;

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

    if (feof (in))
        mLen = -1;

    return mLen;
}

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, ...) {
    char format_buff[1024];
    va_list args;
    
    va_start (args, sformat);
    // fmt = va_arg(args, char*);
    int i=vsprintf (format_buff, sformat, args);
    va_end (args);

    ASSERTWITH (i<1024, "String format result exceeded buffer size (1024 bytes)");
    return format_buff;
}

---