KSG-Framework/Text.cpp

//---Include---
#include "Text.h"

#include <iomanip>
#include <math.h>
#include <sstream>
#ifndef WIN32
#    include <string.h>
#endif
#include "Regex.h"

using namespace Framework;

DynamicBuffer::DynamicBuffer(std::function<int(std::stringbuf&)> onAppend)
    : std::stringbuf(),
      onAppend(onAppend)
{}

int DynamicBuffer::sync()
{
    return onAppend(*this);
}

FlushingOStream::FlushingOStream(
    DynamicBuffer* buffer, std::function<void()> onDestroy)
    : std::ostream(buffer),
      onDestroy(onDestroy)
{}

FlushingOStream::FlushingOStream(const Framework::FlushingOStream& stream)
    : std::ostream(stream.rdbuf())
{}

FlushingOStream::~FlushingOStream()
{
    flush();
    onDestroy();
}

Text::Text(char* t, int l)
    : ReferenceCounter(),
      txt(0),
      length(0),
      suchGBeg(0),
      suchGEnd(0),
      precision(-1),
      stringWriter(0)
{
    length = l;
    txt = t; // neuen Text erstellen
}

// inhalt der Text Klasse aus Text.h
// Konstruktor
Text::Text()
    : ReferenceCounter(),
      txt(0),
      length(0),
      suchGBeg(0),
      suchGEnd(0),
      precision(-1),
      stringWriter(0)
{
    setText("");
}

Text::Text(const Text& txt)
    : ReferenceCounter(),
      txt(0),
      length(0),
      suchGBeg(0),
      suchGEnd(0),
      precision(-1),
      stringWriter(0)
{
    setText(txt, txt.length);
}

Text::Text(const char* t)
    : ReferenceCounter(),
      txt(0),
      length(0),
      suchGBeg(0),
      suchGEnd(0),
      precision(-1),
      stringWriter(0)
{
    setText(t); // Text setzen
}

Framework::Text::Text(const char* txt, int offset, int length)
    : ReferenceCounter(),
      txt(0),
      length(0),
      suchGBeg(0),
      suchGEnd(0),
      precision(-1),
      stringWriter(0)
{
    this->length = length;
    this->txt = new char[length + 1];
    memcpy(this->txt, txt + offset, length);
    this->txt[length] = 0;
}

Text::Text(int zahl)
    : ReferenceCounter(),
      txt(0),
      length(0),
      suchGBeg(0),
      suchGEnd(0),
      precision(-1),
      stringWriter(0)
{
    *this = zahl;
}

// Erstellt ein neues Text Objekt mit einer zahl als text
//  num: Die Zahl, die im Text sein soll
Text::Text(double num)
    : Text()
{
    *this = num;
}

// Erstellt ein neues Text Objekt mit einer zahl als text
//  num: Die Zahl, die im Text sein soll
Text::Text(float num)
    : Text()
{
    *this = num;
}

// Destruktor
Text::~Text()
{
    if (stringWriter) delete stringWriter;
    delete[] txt;
}

void Framework::Text::setTextZ(char* t, int l)
{
    delete[] txt; // alter Text löschen
    length = l;
    txt = t; // neuen Text erstellen
}

void Text::toUpperCase()
{
    if (!txt) return;
    for (int i = 0; i < length; i++)
    {
        if (txt[i] >= 'a' && txt[i] <= 'z') txt[i] = (char)(txt[i] - 32);
        switch (txt[i])
        {
        case 'ü':
            txt[i] = 'Ü';
            break;
        case 'ö':
            txt[i] = 'Ö';
            break;
        case 'ä':
            txt[i] = 'Ä';
            break;
        }
    }
}

void Text::toLowerCase()
{
    if (!txt) return;
    for (int i = 0; i < length; i++)
    {
        if (txt[i] >= 'A' && txt[i] <= 'Z') txt[i] = (char)(txt[i] + 32);
        switch (txt[i])
        {
        case 'Ü':
            txt[i] = 'ü';
            break;
        case 'Ö':
            txt[i] = 'ö';
            break;
        case 'Ä':
            txt[i] = 'ä';
            break;
        }
    }
}

// nicht constant
void Text::setSuchGrenzen(
    char gBeg, char gEnd) // sucht bei jeder suchfunktion nicht zwischen den
                          // Zeichen gBeg und gEnd
{
    suchGBeg = gBeg;
    suchGEnd = gEnd;
}

void Text::setText(const char* t) // ersetzt den Text
{
    setText(t, textLength(t)); // Text setzen
}

// unconstant
void Text::setText(const char* t, int l) // ersetzt den Text
{
    delete[] txt; // alter Text löschen
    length = l;
    txt = new char[(__int64)length + 1]; // neuen Text erstellen
    for (int i = 0; i < length; ++i)     // Text befüllen
        txt[i] = t[i];
    txt[length] = '\0'; // Textende Festlegen
}

void Text::setText(const Text& t)
{
    setText(t, t.getLength()); // Text setzen
}

void Text::append(char c) // hängt an den Text an
{
    append(&c, 1);
}

void Text::append(const char* t) // hängt an den Text an
{
    int tl = (int)textLength(t);                    // länge der übergabe
    char* res = new char[(__int64)tl + length + 1]; // neuen Text erstellen
    for (int i = 0; i < length; ++i)                // mit jetzigem Text füllen
        res[i] = txt[i];
    for (int i = 0; i < tl; ++i) // Übergabe anhängen
        res[length + i] = t[i];
    res[length + tl] = '\0';    // Textende festlegen
    setTextZ(res, length + tl); // Test setzen
}

void Text::appendHex(char num) // hängt die zahl in hex anden Text an
{
    char* res = new char[(__int64)length + sizeof(char) * 2 + 1];
    for (int i = 0; i < length; ++i)
        res[i] = txt[i];
    std::stringstream stream;
    stream << std::setfill('0') << std::setw((int)sizeof(char) * 2) << std::hex
           << (int)num;
    std::string str = stream.str();
    for (int i = length; i < length + sizeof(char) * 2; ++i)
        res[i] = str.c_str()[i - length];
    res[length + sizeof(char) * 2] = 0;
    setTextZ(res, length + sizeof(char) * 2);
}

void Framework::Text::appendHex(short num)
{
    char* res = new char[(__int64)length + sizeof(short) * 2 + 1];
    for (int i = 0; i < length; ++i)
        res[i] = txt[i];
    std::stringstream stream;
    stream << std::setfill('0') << std::setw((int)sizeof(short) * 2) << std::hex
           << num;
    std::string str = stream.str();
    for (int i = length; i < length + sizeof(short) * 2; ++i)
        res[i] = str.c_str()[i - length];
    res[length + sizeof(short) * 2] = 0;
    setTextZ(res, length + sizeof(short) * 2);
}

void Text::appendHex(int num) // hängt die zahl in hex anden Text an
{
    char* res = new char[(__int64)length + sizeof(int) * 2 + 1];
    for (int i = 0; i < length; ++i)
        res[i] = txt[i];
    std::stringstream stream;
    stream << std::setfill('0') << std::setw((int)sizeof(int) * 2) << std::hex
           << num;
    std::string str = stream.str();
    for (int i = length; i < length + sizeof(int) * 2; ++i)
        res[i] = str.c_str()[i - length];
    res[length + sizeof(int) * 2] = 0;
    setTextZ(res, length + sizeof(int) * 2);
}

void Text::appendHex(__int64 num) // hängt die zahl in hex anden Text an
{
    char* res = new char[(__int64)length + sizeof(__int64) * 2 + 1];
    for (int i = 0; i < length; ++i)
        res[i] = txt[i];
    std::stringstream stream;
    stream << std::setfill('0') << std::setw((int)sizeof(__int64) * 2)
           << std::hex << num;
    std::string str = stream.str();
    for (int i = length; i < length + sizeof(__int64) * 2; ++i)
        res[i] = str.c_str()[i - length];
    res[length + sizeof(__int64) * 2] = 0;
    setTextZ(res, length + sizeof(__int64) * 2);
}

void Text::append(const char* t, int l)            // hängt an den Text an
{                                                  // länge des Textes
    char* res = new char[(__int64)l + length + 1]; // neuen Text erstellen
    for (int i = 0; i < length; ++i)               // mit jetzigem Text füllen
        res[i] = txt[i];
    for (int i = 0; i < l; ++i) // Übergabe anhängen
        res[length + i] = t[i];
    res[length + l] = '\0';    // Textende festlegen
    setTextZ(res, length + l); // Test setzen
}

void Text::append(const Text& t)
{
    if (t.getLength() > 0)        // Auf unsinnige übergabe prüfen
        append(t, t.getLength()); // Text anhängen
}

void Text::append(int num)
{
    std::stringstream ss;
    ss << num;
    std::string string = ss.str();
    append(string.c_str(), (int)string.length());
}

// Hängt eine Zahl ans Ende Des Textes an
//  num: Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden
//  soll
void Text::append(__int64 num)
{
    std::stringstream ss;
    ss << num;
    std::string string = ss.str();
    append(string.c_str(), (int)string.length());
}

void Text::append(unsigned int num)
{
    std::stringstream ss;
    ss << num;
    std::string string = ss.str();
    append(string.c_str(), (int)string.length());
}

void Text::append(double num)
{
    std::stringstream ss;
    if (precision >= 0) ss.precision(precision);
    ss << std::fixed << num;
    std::string string = ss.str();
    const char* str = string.c_str();
    int len = (int)string.length();
    for (int i = len - 1; i > 0; i--)
    {
        if (str[i] == '0')
            len--;
        else
        {
            if (str[i] == '.') len--;
            break;
        }
    }
    append(str, len);
}

void Text::append(float num)
{
    std::stringstream ss;
    if (precision >= 0) ss.precision(precision);
    ss << std::fixed << num;
    std::string string = ss.str();
    const char* str = string.c_str();
    int len = (int)string.length();
    for (int i = len - 1; i > 0; i--)
    {
        if (str[i] == '0')
            len--;
        else
        {
            if (str[i] == '.') len--;
            break;
        }
    }
    append(str, len);
}

//! Gibt einen ostream zurück, der alle ausgaben an diesen Text anhängt
FlushingOStream Text::append()
{
    if (!stringWriter)
    {
        stringWriter = new DynamicBuffer([this](std::stringbuf& buf) {
            std::string str = buf.str();
            this->append(str.c_str(), (int)str.length());
            buf.str("");
            return 0;
        });
    }
    return FlushingOStream(stringWriter);
}

void Text::insert(int p, char c) // Fügt an stelle p ein
{
    if (p > length || p < 0) // Auf unsinnige übergabe prüfen
        return;
    char* res = new char[(__int64)length + 2]; // neuer Text erstellen
    for (int i = 0; i < p; ++i)                // Text füllen
        res[i] = txt[i];
    res[p] = c;
    for (int i = p; i < length; ++i) // Text füllen
        res[i + 1] = txt[i];
    res[length + 1] = '\0';    // Text ende festlegen
    setTextZ(res, length + 1); // Text setzen
}

void Text::insert(int p, const char* t) // Fügt an stelle p ein
{
    insert(p, t, textLength(t)); // Text einfügen
}

void Framework::Text::insert(int p, const char* t, int len)
{
    if (p > length || p < 0 || len <= 0) // Auf unsinnige übergabe prüfen
        return;                          // Länge der übergabe
    char* res = new char[(__int64)len + length + 1]; // neuer Text erstellen
    for (int i = 0; i < p; ++i)                      // Text füllen
        res[i] = txt[i];
    for (int i = 0; i < len; ++i) // Text einfügen
        res[i + p] = t[i];
    for (int i = p; i < length; ++i) // Text füllen
        res[i + len] = txt[i];
    res[len + length] = '\0';    // Text ende festlegen
    setTextZ(res, length + len); // Text setzen
}

void Text::insert(int p, const Text& t)
{
    insert(p, t, t.getLength()); // Text einfügen
}

void Framework::Text::regexReplace(
    const char* regex, const char* replacement, Regex::RegexConfig* config)
{
    regexReplace(
        regex, [replacement](Regex::Result&) { return replacement; }, config);
}

void Framework::Text::regexReplace(const char* regex,
    std::function<Text(Regex::Result&)> replacementFunction,
    Regex::RegexConfig* config)
{
    auto matcher
        = config == 0 ? Regex::parse(regex) : Regex::parse(regex, *config);
    if (!matcher) return;
    auto result = matcher->match(txt, length);
    if (result->getEintragAnzahl() > 0)
    {
        int replacedLength = 0;
        int replacementLength = 0;
        Text* replacements = new Text[result->getEintragAnzahl()];
        int i = 0;
#ifdef WIN32
#    pragma warning(push)
#    pragma warning(disable : 6385)
#endif
        for (Regex::Result* match : *result)
        {
            replacedLength += match->getEnd() - match->getStart();
            replacements[i] = replacementFunction(*match);
            replacementLength += replacements[i].getLength();
            i++;
        }
        int newLength = length - replacedLength + replacementLength;
        char* newText = new char[(__int64)newLength + 1];
        int pos = 0;
        int newPos = 0;
        int j = 0;
        for (Regex::Result* match : *result)
        {
            for (int i = 0; i < match->getStart() - pos; i++)
            {
                newText[newPos + i] = txt[pos + i];
            }
            newPos += match->getStart() - pos;
            pos = match->getEnd();
            for (int i = 0; i < replacements[j].getLength(); i++)
            {
                newText[newPos + i] = replacements[j][i];
            }
            newPos += replacements[j].getLength();
            j++;
        }
        for (int i = pos; i < getLength(); i++)
        {
            newText[newPos + i - pos] = txt[i];
        }
#ifdef WIN32
#    pragma warning(pop)
#endif
        newText[newLength] = '\0';
        setTextZ(newText, newLength);
        delete[] replacements;
    }
    result->release();
    matcher->release();
}

void Text::ersetzen(
    int p1, int p2, const char* t) // Ersetzt den Text von p1 bis p2
{
    ersetzen(p1, p2, t, textLength(t)); // Text ersetzen
}

void Framework::Text::ersetzen(int p1, int p2, const char* t, int len)
{
    if (p1 > p2)
    {
        int x = p1; // p1 und p2 tauschen
        p1 = p2;
        p2 = x;
    }
    remove(p1, p2); // Textabschnitt von p1 zu p2 löschen
    if (len > 0)
    {
        insert(p1, t, len); // Übergabe bei p1 einfügen}
    }
}

void Text::ersetzen(int p1, int p2, const Text& t)
{
    ersetzen(p1, p2, t, t.getLength()); // Text ersetzen
}

void Text::ersetzen(char c1, char c2) // ersetzt jedes c1 durch c2
{
    if (c1 == '\0' || c2 == '\0') // Auf unsinnige übergabe prüfen
        return;
    if (!hat(c1)) // prüfen ob c1 vorhanden
        return;
    int suchGCount = 0;
    if (suchGBeg && suchGEnd)
    {
        for (int i = 0; i < length; ++i) // Text durchsuchen
        {
            bool b = suchGCount != 0;
            if (txt[i] == c1 && !suchGCount) txt[i] = c2; // Text ersetzen
            if (txt[i] == suchGBeg) ++suchGCount;
            if (txt[i] == suchGEnd) --suchGCount;
            if (txt[i] == c1 && !suchGCount && b) txt[i] = c2; // Text ersetzen
        }
    }
    else
    {
        for (int i = 0; i < length; ++i) // Text durchsuchen
        {
            if (txt[i] == c1) txt[i] = c2; // Text ersetzen
        }
    }
}

void Text::ersetzen(const char* t1, const char* t2) // ersetzt jedes t1 durch t2
{
    ersetzen(t1, textLength(t1), t2, textLength(t2)); // Text ersetzen
}

void Framework::Text::ersetzen(
    const char* t1, int len1, const char* t2, int len2)
{
    if (len1 > length || len1 <= 0) // Auf unsinnige übergabe prüfen
        return;
    if (!hat(t1, len1)) // prüfen ob t1 vorhanden
        return;
    int anz = anzahlVon(t1, len1); // Anzahl von t1 im Text
    int* begin = new int[anz];
    int* end = new int[anz];
    int searchStart = 0;
    for (int i = 0; i < anz; ++i) // Positionen von t1 speichern
    {
        begin[i] = positionVon(searchStart, t1, len1);
        end[i] = begin[i] + len1;
        searchStart = end[i];
    }
    int resl
        = (length - (anz * len1)) + (anz * len2) + 1; // Länge des Ergebneses
    char* res = new char[resl];                       // neuer Text erstellen
    int rep = 0;              // Speichert bei welchen t1 man sich befindet
    int last = 0;             // Füllposition von txt
    int neu = 0;              // Füllporition von res
    for (; neu < resl; ++neu) // Text befüllen
    {
        if (rep < anz && last == begin[rep]) // Text ersetzen
        {
            last = end[rep];
            ++rep;
            for (int ii = 0; ii < len2; ++ii)
            {
                if (neu >= resl) break;
                res[neu] = t2[ii];
                ++neu;
            }
            if (neu >= resl) break;
            --neu;
        }
        else // Text Kopieren
        {
            res[neu] = txt[last];
            ++last;
        }
    }
    res[resl - 1] = '\0'; // Textende festlegen
    setTextZ(res, resl);  // Text setzen
    delete[] begin;       // Speicher freigeben
    delete[] end;
}

void Text::ersetzen(const Text& t1, const char* t2)
{
    ersetzen(t1, t1.getLength(), t2, textLength(t2)); // Text ersetzen
}

void Text::ersetzen(const char* t1, const Text& t2)
{
    ersetzen(t1, textLength(t1), t2, t2.getLength()); // Text ersetzen
}

void Text::ersetzen(const Text& t1, const Text& t2)
{
    ersetzen(t1, t1.getLength(), t2, t2.getLength()); // Text ersetzen
}

void Text::ersetzen(int index, char c1, char c2) // ersetzt das i-te c1 durch c2
{
    if (c1 == '\0' || c2 == '\0' || index < 0) // Auf unsinnige übergabe prüfen
        return;
    if (!hat(c1)) // prüfen ob c1 vorhanden
        return;
    int anz = anzahlVon(c1);
    if (index >= anz) // prüfen ob es ein i-tes c1 gibt
        return;
    txt[positionVon(c1, index)] = c2;
}

void Text::ersetzen(int index,
    const char* t1,
    const char* t2) // ersetzt das i-te t1 durch t2
{
    ersetzen(index, t1, textLength(t1), t2, textLength(t2)); // Text ersetzen
}

void Framework::Text::ersetzen(
    int index, const char* t1, int len1, const char* t2, int len2)
{
    if (len1 >= length || len1 <= 0
        || index < 0) // Auf unsinnige übergabe prüfen
        return;
    if (!hat(t1)) // prüfen ob t1 vorhanden
        return;
    int anz = anzahlVon(t1, len1); // Anzahl von t1 im Text
    if (index >= anz)              // prüfen ob es ein i-tes t1 gibt
        return;
    int begin = positionVon(index, len1, t1);
    int end = begin + len1;
    ersetzen(begin, end, t2, len2); // ersetzen
}

void Text::ersetzen(int i, const Text& t1, const char* t2)
{
    ersetzen(i, t1, t1.getLength(), t2, textLength(t2)); // ersetzen
}

void Text::ersetzen(int i, const char* t1, const Text& t2)
{
    ersetzen(i, t1, textLength(t1), t2, t2.getLength()); // ersetzen
}

void Text::ersetzen(int i, const Text& t1, const Text& t2)
{
    ersetzen(i, t1, t1.getLength(), t2,
        t2.getLength()); // ersetzen
}

void Text::fillText(
    char c, int len) // setzt den Text zu so vielen c wie län groß ist
{
    char* res = new char[(__int64)len + 1];
    for (int i = 0; i < len; ++i)
        res[i] = c;
    res[len] = '\0';
    setTextZ(res, len);
}

void Text::remove(int p) // löscht p
{
    if (p < 0 || p >= length) // Auf unsinnige übergabe prüfen
        return;
    char* res = new char[length];             // neuen Text anlegen
    for (int i = 0; i < p && i < length; ++i) // Text befüllen
        res[i] = txt[i];
    for (int i = p + 1; i < length; ++i)
        res[i - 1] = txt[i];
    res[length - 1] = 0;
    setTextZ(res, length - 1); // Text setzen
}

void Text::remove(int p1, int p2) // löscht von p1 zu p2 ( p2 bleibt )
{
    if (p1 == p2) return;
    if (p1 > p2) // p1 und p2 tauschen
    {
        int x = p1;
        p1 = p2;
        p2 = x;
    }
    if (p1 < 0) // Auf unsinnige übergabe prüfen
        p1 = 0;
    if (p2 > length) p2 = length;
    int resl = length - (p2 - p1);           // Länge vom Ergebnis
    char* res = new char[(__int64)resl + 1]; // Neuen Text erstellen
    memcpy(res, txt, p1);
    memcpy(res + p1, txt + p2, length - p2);
    res[resl] = '\0';    // Testende festlegen
    setTextZ(res, resl); // Text setzen
}

void Text::remove(char c) // löscht jetes c
{
    if (!hat(c)) // prüfen ob c vorhanden
        return;
    int anz = anzahlVon(c);                          // Anzahl von c
    char* res = new char[(__int64)length - anz + 1]; // neuen Text erstellen
    int anz2 = 0;
    int suchGCount = 0;
    for (int i = 0; i < length; ++i) // Text befüllen
    {
        bool b = suchGCount != 0;
        if (txt[i] == c && !suchGCount)
            ++anz2;
        else
            res[i - anz2] = txt[i];
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (b)
        {
            if (txt[i] == c && !suchGCount)
                ++anz2;
            else
                res[i - anz2] = txt[i];
        }
    }
    res[length - anz] = '\0';    // Textende festlegen
    setTextZ(res, length - anz); // Text setzen
}

void Text::remove(const char* t) // löscht jetes t
{
    remove(t, textLength(t)); // Text löschen
}

void Framework::Text::remove(const char* t, int len)
{
    if (len <= 0 || len > length) // Auf unsinnige übergabe prüfen
        return;
    if (!hat(t, len)) // prüfen ob Text ein t enthält
        return;
    int anz = anzahlVon(t, len); // anzahl von t
    int* begin = new int[anz];
    for (int i = 0; i < anz; ++i) // begin aller t-s finden
        begin[i] = positionVon(i, len, t);
    int resl = length - (anz * len);         // Länge vom Ergebnes
    char* res = new char[(__int64)resl + 1]; // neuen Text erzeugen
    int del = 0;
    for (int i = 0; i < length; ++i) // Text befüllen
    {
        if (del < anz && i == begin[del]) // Text auslassen
        {
            i += len - 1;
            ++del;
        }
        else
            res[i - (del * len)] = txt[i]; // Text befüllen
    }
    res[resl] = '\0';    // Text ende festlegen
    setTextZ(res, resl); // Text setzen
    delete[] begin;
}

void Text::remove(const Text& t)
{
    remove(t, t.getLength()); // Text löschen
}

void Text::remove(int index, char c)
{
    if (index < 0 || !hat(c)) // Auf unsinnige übergabe prüfen
        return;
    int anz = anzahlVon(c); // anzahl der i-s
    if (index >= anz)       // prüfen ob ein i-tes c vorhanden ist
        return;
    int pos = positionVon(c, index); // Position vom i-ten c
    if (pos < 0) return;
    if (!length) return;
    char* res = new char[length];               // neuen Text erzeugen
    for (int i = 0; i < pos && i < length; ++i) // Text befüllen
        res[i] = txt[i];
    for (int i = pos + 1; i < length; ++i)
        res[i - 1] = txt[i];
    res[length - 1] = '\0';    // Text ende festlegen
    setTextZ(res, length - 1); // Text setzen
}

void Text::remove(int index, const char* t) // löscht das i-te t
{
    remove(index, t, textLength(t)); // Text löschen
}

void Framework::Text::remove(int index, const char* t, int len)
{
    if (index < 0 || !hat(t, len) || len <= 0) // Auf unsinnige übergabe prüfen
        return;
    int anz = anzahlVon(t, len); // anzahl der i-s
    if (index >= anz)            // prüfen ob ein i-tes c vorhanden ist
        return;
    int pos = positionVon(index, len, t); // Position vom i-ten c
    if (pos < 0) return;
    if (!length) return;
    char* res = new char[(__int64)length - len + 1];      // neuen Text erzeugen
    for (int i = 0; i < pos && i < length - len + 1; ++i) // Text befüllen
        res[i] = txt[i];
    for (int i = pos + len; i < length; ++i)
        res[i - len] = txt[i];
    res[length - len] = '\0';    // Text ende festlegen
    setTextZ(res, length - len); // Text setzen
}

void Text::remove(int i, const Text& t)
{
    remove(i, t, t.getLength()); // Text löschen
}

// Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
//  pos: Die Position des ersten zeichens
int Text::removeWhitespaceAfter(int pos)
{
    int removedLength = 0;
    for (int i = pos; i < length; i++)
    {
        if (txt[i] == ' ' || txt[i] == '\n' || txt[i] == '\r' || txt[i] == '\t')
            removedLength++;
        else
            break;
    }
    remove(pos, pos + removedLength);
    return length;
}

// Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
//  pos: Die Position des ersten zeichens (beginnt bei pos-1)
int Text::removeWhitespaceBefore(int pos)
{
    int length = 0;
    for (int i = pos - 1; i >= 0; i--)
    {
        if (txt[i] == ' ' || txt[i] == '\n' || txt[i] == '\r' || txt[i] == '\t')
            length++;
        else
            break;
    }
    remove(pos - length, pos);
    return length;
}

void Text::setPrecision(
    int p) // setzt die Anzahl der Nachkommastellen bei doubles
{
    precision = p;
}

// constant
int Text::getLength() const // gibt die Text länge zurück
{
    return length;
}

int Text::getLKick(int pos) const
{
    if (txt[pos - 1] == ' ')
    {
        int ret = 1;
        for (; ret < pos && txt[pos - ret - 1] == ' '
               && txt[pos - ret - 1] != '\n';
            ++ret)
            ;
        return pos - ret;
    }
    else
    {
        int ret = 1;
        for (; ret < pos && txt[pos - ret - 1] != ' '
               && txt[pos - ret - 1] != '\n';
            ++ret)
            ;
        return pos - ret;
    }
}

int Text::getOKick(int pos) const
{
    if (!hat('\n')) return 0;
    int lpos = 0;
    while (pos - lpos - 1 > 0 && txt[pos - lpos - 1] != '\n')
        ++lpos;
    int vllen = 1;
    while (pos - lpos - vllen - 1 >= 0 && txt[pos - lpos - vllen - 1] != '\n')
        ++vllen;
    if (vllen > lpos)
        return pos - vllen;
    else
        return pos - lpos - 1;
}

int Text::getRKick(int pos) const
{
    if (txt[pos] == ' ')
    {
        int ret = 1;
        for (; ret + pos < length && txt[pos + ret] == ' '
               && txt[pos + ret] != '\n';
            ++ret)
            ;
        return pos + ret;
    }
    else
    {
        int ret = 1;
        for (; ret + pos < length && txt[pos + ret] != ' '
               && txt[pos + ret] != '\n';
            ++ret)
            ;
        return pos + ret;
    }
}

int Text::getUKick(int pos) const
{
    if (!hat('\n')) return length;
    int lpos = 0;
    while (pos - lpos > 0 && txt[pos - lpos - 1] != '\n')
        ++lpos;
    int llen = 1;
    while (pos + llen - 1 < length && txt[pos + llen - 1] != '\n')
        ++llen;
    int vllen = 1;
    while (
        pos + llen + vllen - 1 < length && txt[pos + llen + vllen - 1] != '\n')
        ++vllen;
    if (vllen == 1) return pos + llen < length ? pos + llen : length;
    if (vllen < lpos) return pos + llen + vllen - 1;
    return pos + llen + lpos;
}

bool Text::hat(const Text& t) const // enthält der Text t
{
    return hat(t, t.getLength()); // Text überprüfen
}

bool Text::hat(const char* t) const
{
    return hat(t, textLength(t)); // Text überprüfen
}

bool Framework::Text::hat(const char* t, int len) const
{
    return hat(0, t, len);
}

bool Framework::Text::hat(int searchStartIndex, const char* t) const
{
    return hat(searchStartIndex, t, textLength(t)); // Text überprüfen
}

bool Framework::Text::hat(int searchStartIndex, const char* t, int len) const
{
    if (len <= 0
        || len > length - searchStartIndex) // Auf unsinnige übergabe prüfen
        return 0;
    int suchGCount = 0;
    for (int i = searchStartIndex; i + len <= length; ++i) // Text durchsuchen
    {
        bool searched = 0;
        if (!suchGCount)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // Text überprüfen
                b &= txt[i + ii] == t[ii];
            if (b) return 1;
            searched = 1;
        }
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (!suchGCount && !searched)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // Text überprüfen
                b &= txt[i + ii] == t[ii];
            if (b) return 1;
        }
    }
    return 0;
}

// Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
//  t: Der Text, nach dessen Inhalt gesucht werden soll
//  return: (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
//  pos: die position an der die zeichenkette im string beginnen soll
bool Text::hatAt(int pos, const Text& t) const
{
    return hatAt(pos, t, t.getLength()); // Text überprüfen
}

// Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
//  t: Die Zeichenkette, nach der gesucht werden soll
//  return: (true), wenn die Zeichenkette vorkommt. (false) sonnst
//  pos: die position an der die zeichenkette im string beginnen soll
bool Text::hatAt(int pos, const char* t) const
{
    return hatAt(pos, t, textLength(t)); // Text überprüfen
}

bool Framework::Text::hatAt(int pos, const char* t, int len) const
{
    if (len <= 0 || len + pos > length) // Auf unsinnige übergabe prüfen
        return 0;
    bool b = 1;
    for (int i = 0; i < len; ++i) // Text überprüfen
        b &= txt[pos + i] == t[i];
    return b;
}

bool Text::hat(char c) const // enthält c
{
    bool ret = 0;
    int suchGCount = 0;
    for (int i = 0; i < length; ++i) // suchen
    {
        bool b = suchGCount != 0;
        if (!suchGCount) // überprüfen
            ret |= txt[i] == c;
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (!suchGCount && b) // überprüfen
            ret |= txt[i] == c;
    }
    return ret;
}

bool Text::beginnsWith(const char* t) const
{
    return hatAt(0, t);
}

bool Text::endsWith(const char* t) const
{
    int len = textLength(t);
    return hatAt(length - len, t, len);
}

bool Text::istGleich(const char* t) const // prüft ob det Text gleich t ist
{
    return istGleich(t, textLength(t)); // Text überprüfen
}

bool Text::istGleich(
    const char* t, int len) const // prüft ob det Text gleich t ist
{
    if (length != len) // Auf unsinniege Übergabe prüfen
        return 0;
    if (length == -1) return 1;
    bool ret = true;
    for (int i = 0; i < len; ++i) // prüfen
        ret &= txt[i] == t[i];
    return ret;
}

bool Text::istGleich(const Text& t) const
{
    return istGleich(t, t.getLength()); // Text überprüfen
}

const char* Text::getText() const // gibt Text zurück
{
    return txt;
}

int Text::anzahlVon(char c) const // gibt die Anzahl von c im Text zurück
{
    int ret = 0;
    int suchGCount = 0;
    if (suchGBeg && suchGEnd)
    {
        for (int i = 0; i < length; ++i) // suchen
        {
            bool b = suchGCount != 0;
            ret += txt[i] == c && !suchGCount; // zählen
            if (txt[i] == suchGBeg) ++suchGCount;
            if (txt[i] == suchGEnd) --suchGCount;
            ret += txt[i] == c && !suchGCount && b; // zählen
        }
    }
    else
    {
        for (int i = 0; i < length; ++i) // suchen
        {
            ret += txt[i] == c; // zählen
        }
    }
    return ret;
}

int Text::anzahlVon(const char* t) const // gibt die Anzahl von t im Text zurück
{
    return anzahlVon(t, textLength(t)); // Text überprüfen
}

int Framework::Text::anzahlVon(const char* t, int len) const
{
    if (len <= 0 || len > length) // Auf unsinnige übergabe prüfen
        return 0;
    int ret = 0;
    int suchGCount = 0;
    for (int i = 0; i + len <= length; ++i) // suchen
    {
        bool b = suchGCount != 0;
        if (!suchGCount)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // überprüfen
                b &= txt[i + ii] == t[ii];
            if (b) ++ret; // zählen
        }
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (!suchGCount && b)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // überprüfen
                b &= txt[i + ii] == t[ii];
            if (b) ++ret; // zählen
        }
    }
    return ret;
}

int Text::anzahlVon(const Text& t) const
{
    return anzahlVon(t, t.getLength()); // Text überprüfen
}

int Text::positionVon(char c) const // gibt die Position des ersten c zurück
{
    int suchGCount = 0;
    for (int i = 0; i < length; ++i) // suchen
    {
        bool b = suchGCount != 0;
        if (txt[i] == c && !suchGCount) // überprüfen
            return i;
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (txt[i] == c && !suchGCount && b) // überprüfen
            return i;
    }
    return -1;
}

int Text::positionVon(
    const char* t) const // gibt die Position des ersten t zurück
{
    return positionVon(textLength(t), t);
}

int Framework::Text::positionVon(int len, const char* t) const
{
    return positionVon(0, t, len);
}

int Text::positionVon(int searchStart, const char* t, int len) const
{
    if (len <= 0 || len > length - searchStart) // Auf unsinnige übergabe prüfen
        return -1;
    int suchGCount = 0;
    for (int i = searchStart; i + len <= length; ++i) // suchen
    {
        bool b = suchGCount != 0;
        if (!suchGCount)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // überprüfen
                b &= txt[i + ii] == t[ii];
            if (b) return i;
        }
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (!suchGCount && b)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // überprüfen
                b &= txt[i + ii] == t[ii];
            if (b) return i;
        }
    }
    return -1;
}

int Text::positionVon(const Text& t) const
{
    return positionVon(t.getLength(), t); // Text überprüfen
}

int Text::positionVon(
    char c, int index) const // gibt die Position des i-ten c zurück
{
    int ii = 0;
    int suchGCount = 0;
    for (int i = 0; i < length; ++i) // suchen
    {
        bool b = suchGCount != 0;
        if (txt[i] == c && !suchGCount) // überprüfen
        {
            if (ii == index)
                return i;
            else
                ++ii;
        }
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (txt[i] == c && !suchGCount && b) // überprüfen
        {
            if (ii == index)
                return i;
            else
                ++ii;
        }
    }
    return -1;
}

int Text::positionVon(
    const char* t, int index) const // gibt die Position des i-ten t zurück
{
    return positionVon(index, textLength(t), t); // Text überprüfen
}

int Framework::Text::positionVon(int index, int len, const char* t) const
{
    if (len <= 0 || len > length) // Auf unsinnige übergabe prüfen
        return 0;
    int i2 = 0;
    int suchGCount = 0;
    for (int i = 0; i + len <= length; ++i) // suchen
    {
        bool b = suchGCount != 0;
        if (!suchGCount)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // überprüfen
                b &= txt[i + ii] == t[ii];
            if (b)
            {
                if (i2 == index)
                    return i;
                else
                    ++i2;
            }
        }
        if (txt[i] == suchGBeg) ++suchGCount;
        if (txt[i] == suchGEnd) --suchGCount;
        if (!suchGCount && b)
        {
            bool b = 1;
            for (int ii = 0; ii < len; ++ii) // überprüfen
                b &= txt[i + ii] == t[ii];
            if (b)
            {
                if (i2 == index)
                    return i;
                else
                    ++i2;
            }
        }
    }
    return -1;
}

int Text::positionVon(const Text& t, int i) const
{
    return positionVon(i, t.getLength(), t); // Text überprüfen
}

Text* Text::getTeilText(
    int p1, int p2) const // gibt den Text von p1 bis p2 zurück
{
    if (p1 > p2) // p1 und p2 tauschen
    {
        int x = p1;
        p1 = p2;
        p2 = x;
    }
    if (p1 < 0 || p2 > length) // Auf unsinnige übergabe prüfen
        return new Text("");
    char* cp = new char[(__int64)p2 - p1 + 1]; // neuen Text erstellen
    for (int i = p1; i < p2; ++i)              // Text befüllen
    {
        cp[i - p1] = txt[i];
    }
    cp[p2 - p1] = '\0';
    return new Text(cp, p2 - p1); // Text zurückgeben
}

Text* Text::getTeilText(int p) const // gibt den Text von p bis zum Ende zurück
{
    return getTeilText(p, getLength()); // Text zurückgeben
}

// berechnet den Hash code des textes
int Text::hashCode() const
{
    int result = 0;
    for (int i = 0; i < length; i++)
        result += (int)pow(txt[i] * 31, length - 1 - i);
    return result;
}

// Operatoren
Text& Text::operator+=(const int num)
{
    append(num);
    return *this;
}

// Hängt eine Zahl ans Ende des Textes an
Text& Text::operator+=(const __int64 num)
{
    append(num);
    return *this;
}

Text& Text::operator+=(const double num)
{
    append(num);
    return *this;
}

Text& Text::operator+=(const float num)
{
    append(num);
    return *this;
}

Text& Text::operator+=(const char* txt)
{
    append(txt);
    return *this;
}

Text& Text::operator+=(const Text& txt)
{
    append(txt, txt.getLength());
    return *this;
}

Text& Text::operator=(const int num)
{
    setText("", 0);
    append(num);
    return *this;
}

Text& Text::operator=(const double num)
{
    setText("", 0);
    append(num);
    return *this;
}

Text& Text::operator=(const float num)
{
    setText("", 0);
    append(num);
    return *this;
}

Text& Text::operator=(const char* txt)
{
    setText(txt);
    return *this;
}

Text& Text::operator=(const Text& txt)
{
    setText(txt, txt.getLength());
    return *this;
}

Text::operator const char*() const
{
    return txt;
}

Text::operator int() const
{
    if (length > 2 && txt[0] == '0' && txt[1] == 'x')
        return TextZuInt((txt + 2), 16);
    return TextZuInt(txt, 10);
}

Text::operator __int64() const
{
    if (length > 2 && txt[0] == '0' && txt[1] == 'x')
        return TextZuInt64((txt + 2), 16);
    return TextZuInt64(txt, 10);
}

Text::operator double() const
{
    return TextZuDouble(txt);
}

Text::operator float() const
{
    return TextZuFloat(txt);
}

bool Text::operator>(Text& t) const
{
    int len2 = t.getLength();
    const char* txt2 = t;
    for (int i = 0; i < length && i < len2; ++i)
    {
        if (txt[i] > txt2[i]) return 1;
        if (txt[i] < txt2[i]) return 0;
    }
    if (length > len2) return 1;
    return 0;
}

bool Text::operator<(Text& t) const
{
    int len2 = t.getLength();
    const char* txt2 = t;
    for (int i = 0; i < length && i < len2; ++i)
    {
        if (txt[i] < txt2[i]) return 1;
        if (txt[i] > txt2[i]) return 0;
    }
    if (length < len2) return 1;
    return 0;
}

// Erstellt einen neuen Text bestehend aus diesem und t2
Text Text::operator+(const Text& t2) const
{
    return Text(*this) += t2;
}

// Erstellt einen neuen Text bestehend aus diesem und t2
Text Text::operator+(const char* t2) const
{
    return Text(*this) += t2;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+(const int num) const
{
    return Text(*this) += num;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+(const __int64 num) const
{
    return Text(*this) += num;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+(const double num) const
{
    return Text(*this) += num;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+(const float num) const
{
    return Text(*this) += num;
}

bool Text::operator==(const Text& right) const
{
    return istGleich(right, right.getLength());
}

Text Text::fromArray(char* arr, int len)
{
    return Text(arr, len);
}

const Text Text::EMPTY = "";

// Inhalt der TextReader Klasse
// Konstructor
//  txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern
//  direkt gelesen.
TextReader::TextReader(Text* txt)
    : ReferenceCounter()
{
    this->txt = txt;
    lPos = 0;
}

// Destructor
TextReader::~TextReader()
{
    txt->release();
}

// Setzt die Position des Bytes, das als nächstes gelesen werden soll
//  pos: Der Index des Bytes
//  ende: 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom
//  Beginn des Textes zählt
void TextReader::setLPosition(__int64 pos, bool ende)
{
    int l = txt->getLength();
    lPos = ende ? l - pos : pos;
    if (lPos < 0) lPos = 0;
    if (lPos > l) lPos = l;
}

// Ließt aus der Datei
//  bytes: Ein Array, der mit Bytes aus dem Text gefüllt werden soll
//  len: Wie viele Bytes aus dem Text gelesen werden sollen
void TextReader::lese(char* bytes, int len)
{
    int l = txt->getLength();
    len = (int)MIN(l - lPos, len);
    for (__int64 i = lPos; i < lPos + len; i++)
        bytes[i - lPos] = txt->getText()[i];
    lPos += len;
}

// Ließt die nächste zeile des Textes ein
//  return: Die gelesene Zeile als Text mit zeilenumbruch
Text* TextReader::leseZeile()
{
    if (istEnde()) return 0;
    Text* ret = new Text("");
    __int64 len = txt->getLength();
    for (char c = 0; c != '\n' && lPos < len;)
    {
        lese(&c, 1);
        if (c) ret->append(&c, 1);
    }
    return ret;
}

// Prüft, ob die Resource vollständig gelesen wurde
//  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
bool TextReader::istEnde() const
{
    return lPos >= txt->getLength();
}

// Gibt den Index des Bytes aus dem Text zurück, welches als nächstes
// gelesen werden würde return -1, falls ein Fehler aufgetreten ist. Sonst
// die Position des Lesezeigers
__int64 TextReader::getLPosition() const
{
    return lPos;
}

//! Gibt die Anzahl der zu lesenden Bytes zurück
__int64 TextReader::getSize() const
{
    return txt->getLength();
}

// char* operationen
int Framework::stringPositionVonChar(const char* string,
    char c,
    int num) // sucht die position des num-ten c-s
             // in string, -1 bei nicht gefunden
{
    int gef = 0;
    int p = 0;
    for (char cc = *string; *string; ++string)
    {
        if (cc == c)
        {
            if (gef == num)
                return p;
            else
                ++gef;
        }
        ++p;
    }
    return -1;
}

int Framework::stringPositionVonString(const char* string,
    char* suche,
    int sBegPos) // sucht die position von 'suche' in 'string' ab der
                 // Position 'sBegPos', -1 bei nicht gefunden
{
    for (int i = 0; i < sBegPos; ++i)
    {
        if (!*string) return -1;
        ++string;
    }
    int tl = textLength(suche);   // Länge der Übergabe
    int txl = textLength(string); // Länge des Textes
    if (tl <= 0 || tl > txl)      // Auf unsinnige übergabe prüfen
        return -1;
    for (int i = 0; i + tl <= txl; ++i) // suchen
    {
        bool b = 1;
        for (int ii = 0; ii < tl; ++ii) // überprüfen
            if (b) b = string[i + ii] == suche[ii];
        if (b) return i + sBegPos;
    }
    return -1;
}

//---Andere Funktionen---
void Framework::TextKopieren(
    const char* txt) // kopiert den Text in den Zwischenspeicher
{
#ifdef WIN32
    int län = textLength(txt) + 1;
    if (län == 1) return;
    HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, län);
    if (!hMem) return;
    memcpy(GlobalLock(hMem), txt, län);
    GlobalUnlock(hMem);
    OpenClipboard(0);
    EmptyClipboard();
    SetClipboardData(CF_TEXT, hMem);
    CloseClipboard();
#endif
}

const char*
Framework::TextInsert() // gibt den Text aus der Zwischenablage zurück
{
#ifdef WIN32
    if (!OpenClipboard(0)) return "";
    HANDLE hClipData = GetClipboardData(CF_TEXT);
    char* cBuffer = (char*)GlobalLock(hClipData);
    GlobalUnlock(hClipData);
    CloseClipboard();
    return cBuffer;
#else
    return 0;
#endif
}

char Framework::smallOrBig(char c, bool gr)
{
    int ret = c;
    if (gr)
    {
        if (c >= 'a' && c <= 'z')
            ret -= 32;
        else
        {
            switch (c)
            {
            case '^':
                return '°';
            case '1':
                return '!';
            case '<':
                return '>';
            case '2':
                return '\"';
            case '3':
                return '§';
            case '4':
                return '$';
            case '5':
                return '%';
            case '6':
                return '&';
            case '7':
                return '/';
            case '8':
                return '(';
            case '9':
                return ')';
            case '0':
                return '=';
            case ',':
                return ';';
            case '.':
                return ':';
            case 'ß':
                return '?';
            case '-':
                return '_';
            case '´':
                return '`';
            case '+':
                return '*';
            case '#':
                return '\'';
            case 'ü':
                return 'Ü';
            case 'ö':
                return 'Ö';
            case 'ä':
                return 'Ä';
            }
        }
    }
    else
    {
        if (c >= 'A' && c <= 'Z')
            ret += 32;
        else
        {
            switch (c)
            {
            case '°':
                return '^';
            case '!':
                return '1';
            case '>':
                return '<';
            case '\"':
                return '2';
            case '§':
                return '3';
            case '$':
                return '4';
            case '%':
                return '5';
            case '&':
                return '6';
            case '/':
                return '7';
            case '(':
                return '8';
            case ')':
                return '9';
            case '=':
                return '0';
            case ';':
                return ',';
            case ':':
                return '.';
            case '?':
                return 'ß';
            case '_':
                return '-';
            case '`':
                return '´';
            case '*':
                return '+';
            case '\'':
                return '#';
            case 'Ü':
                return 'ü';
            case 'Ö':
                return 'ö';
            case 'Ä':
                return 'ä';
            }
        }
    }
    return (char)ret;
}

bool Framework::istSchreibbar(
    unsigned char zeichen) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
{
    if (zeichen > 32 && zeichen < 127) return 1;
    if (zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179)
        return 1;
    if (zeichen > 191 && zeichen < 198) return 1;
    if (zeichen > 199 && zeichen < 208) return 1;
    if (zeichen > 209 && zeichen < 215) return 1;
    if (zeichen > 216 && zeichen < 221) return 1;
    if (zeichen > 222 && zeichen < 230) return 1;
    if (zeichen > 231 && zeichen < 240) return 1;
    if (zeichen > 241 && zeichen < 247) return 1;
    if (zeichen > 248 && zeichen < 253) return 1;
    if (zeichen == ' ' || zeichen == '\t') return 1;
    return 0;
}

unsigned int Framework::TextZuInt(
    const char* c, int system) // Konvertiert c zu int
{
    if (system == 16) return (unsigned int)strtoul(c, 0, system);
    return (unsigned int)strtol(c, 0, system);
}

unsigned int Framework::TextZuInt(const char* c, char** c_ende, int system)
{
    if (system == 16) return (unsigned int)strtoul(c, c_ende, system);
    return (unsigned int)strtol(c, c_ende, system);
}

unsigned __int64 Framework::TextZuInt64(const char* c, int system)
{
    if (system == 16) return strtoull(c, 0, system);
    return (unsigned __int64)strtoll(c, 0, system);
}

unsigned __int64 Framework::TextZuInt64(
    const char* c, char** c_ende, int system)
{
    if (system == 16) return strtoull(c, c_ende, system);
    return (unsigned __int64)strtoll(c, c_ende, system);
}

double Framework::TextZuDouble(const char* c) // Konvertiert c zu double
{
    return strtod(c, 0);
}

float Framework::TextZuFloat(const char* c) // Konvertiert c zu double
{
    return strtof(c, 0);
}

double Framework::TextZuDouble(const char* c, char** c_ende)
{
    return strtod(c, c_ende);
}

float Framework::TextZuFloat(const char* c, char** c_ende)
{
    return strtof(c, c_ende);
}

int Framework::textLength(const char* txt) // gibt die Länge von txt zurück
{
    if (!txt) return 0;
    int ret = 0;
    for (; txt[ret]; ++ret)
        ;
    return ret;
}