#include "KSGSBefehl.h"
#include "../Error/Error.h"
#include "../Leser/KSGSLeser.h"
#include "../Leser/KSGSCompile.h"
#include "../Main/KSGScriptObj.h"
#include "KSGSKlasse.h"
#include "../Klassen/KSGSInt.h"
#include "../Klassen/KSGSDouble.h"
#include "../Klassen/KSGSBool.h"
#include "../Klassen/KSGSText.h"
#include "../Klassen/KSGSTyp.h"

using namespace KSGScript;

// Befehls Strukturen
KSGSBefehlVariable::KSGSBefehlVariable( Text *txt, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT,
                                        const char *klassName, const char *funktionName, int *typId, bool *ok )
{
    txt->setSuchGrenzen( '(', ')' );
    removeKlammer( txt );
    Text name = txt->getText();
    txt->release();
    *ok = 0;
    if( !funktionName && !klassName )
        return;
    KSGSCompFuncTable *zLFT = zFT;
    KSGSCompVarTable *zLVT = zVT;
    if( klassName )
    {
        if( !zKT->hat( klassName ) )
            return;
        zLFT = &zKT->get( klassName )->funcs;
        zLVT = &zKT->get( klassName )->vars;
    }
    if( *typId >= 0 )
    { // Variable gehört zu einem anderen Zeichnung
        if( !zKT->hat( *typId ) || !zKT->get( *typId )->vars.hat( name ) )
            return;
        varId = zKT->get( *typId )->vars.get( name )->id;
        varSichtbar = zKT->get( *typId )->vars.get( name )->sichtbar;
        *typId = zKT->get( *typId )->vars.get( name )->typ;
    }
    else
    { // Variable gehört zu diesem Zeichnung
        if( !zLFT->hat( funktionName ) )
            return;
        if( zLFT->get( funktionName )->vars.hat( name ) )
        {
            varId = zLFT->get( funktionName )->vars.get( name )->id;
            *typId = zLFT->get( funktionName )->vars.get( name )->typ;
            varSichtbar = zLFT->get( funktionName )->vars.get( name )->sichtbar;
        }
        else if( zLVT->hat( name ) )
        {
            varId = zLVT->get( name )->id;
            *typId = zLVT->get( name )->typ;
            varSichtbar = zLVT->get( name )->sichtbar;
        }
        else if( zVT->hat( name ) )
        {
            varId = zVT->get( name )->id;
            *typId = zVT->get( name )->typ;
            varSichtbar = zVT->get( name )->sichtbar;
        }
        else
            return;
    }
    *ok = 1;
}

KSGSBefehlFunktion::KSGSBefehlFunktion( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT,
                                        const char *klassName, const char *funktionName, int *typId, bool *ok )
{
    *ok = 0;
    int retTyp = -1;
    txt->setSuchGrenzen( '(', ')' );
    removeKlammer( txt );
    if( !txt->hat( '(' ) || ( !klassName && !funktionName ) )
    {
        txt->release();
        return;
    }
    Text *name = txt->getTeilText( 0, txt->positionVon( '(' ) );
    Text *parameter = txt->getTeilText( txt->positionVon( '(' ) );
    txt->release();
    name->setSuchGrenzen( '(', ')' );
    removeKlammer( name );
    parameter->setSuchGrenzen( '(', ')' );
    removeKlammer( parameter );
    KSGSCompFuncTable *zLFT = zFT;
    if( klassName )
    {
        if( !zKT->hat( klassName ) )
        {
            name->release();
            parameter->release();
            return;
        }
        zLFT = &zKT->get( klassName )->funcs;
    }
    if( *typId >= 0 )
    { // Funktion gehört zu anderem Zeichnung
        if( !zKT->hat( *typId ) )
        {
            name->release();
            parameter->release();
            return;
        }
        zLFT = &zKT->get( *typId )->funcs;
    }
    Array< int > *paramTyps = 0;
    bool noWarn = 0;
    if( zLFT->hat( *name ) )
    {
        funcId = zLFT->get( *name )->id;
        if( funcId == 0 && name->istGleich( "Rückruf" ) )
            noWarn = 1;
        funkSichtbar = zLFT->get( *name )->sichtbar;
        paramTyps = &zLFT->get( *name )->parameterTyp;
        retTyp = zLFT->get( *name )->typ;
    }
    else if( *typId < 0 && zFT->hat( *name ) )
    {
        funcId = zFT->get( *name )->id;
        if( funcId == 0 && name->istGleich( "Rückruf" ) )
            noWarn = 1;
        funkSichtbar = zFT->get( *name )->sichtbar;
        paramTyps = &zFT->get( *name )->parameterTyp;
        retTyp = zFT->get( *name )->typ;
    }
    else
    {
        name->release();
        parameter->release();
        return;
    } // Parameter
    int ptAnz = paramTyps->getEintragAnzahl();
    int pAnz = parameter->anzahlVon( ',' ) + 1;
    if( !parameter->getLength() )
        pAnz = 0;
    if( ptAnz != pAnz )
    {
        if( !noWarn )
            error( 14, { dbg->datei, Text() += dbg->zeile }, zObj );
        ptAnz = ptAnz < pAnz ? pAnz : ptAnz;
    }
    for( int i = 0; i < ptAnz; i++ )
    { // für jeden Parameter
        int beg = 0;
        int end = parameter->getLength();
        if( i > 0 )
            beg = parameter->positionVon( ',', i - 1 ) + 1;
        if( i < ptAnz - 1 )
            end = parameter->positionVon( ',', i );
        Text *p = parameter->getTeilText( beg, end );
        bool b = 0;
        int pTyp = -1;
        KSGSBefehlParameter *param = new KSGSBefehlParameter( zObj, p, dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b );
        if( !b )
        {
            name->release();
            parameter->release();
            delete param;
            return;
        }
        this->parameter.add( param );
    }
    name->release();
    parameter->release();
    *typId = retTyp;
    *ok = 1;
}

KSGSBefehlFunktion::~KSGSBefehlFunktion()
{
    int anz = parameter.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        delete parameter.get( i );
}

KSGSBefehlMember::KSGSBefehlMember( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                    KSGSCompVarTable *zVT, const char *klassName, const char *funktionName, int *typId, bool *ok )
{
    *ok = 0;
    bef = 0;
    funk = 0;
    var = 0;
    txt->setSuchGrenzen( '(', ')' );
    removeKlammer( txt );
    Text abschnitt = txt->getText();
    abschnitt.setSuchGrenzen( '(', ')' );
    txt->release();
    if( hatOperator( &abschnitt ) >= 0 )
    { // Befehl
        typ = BEFEHL;
        KSGSLeseBefehl *tmp = new KSGSLeseBefehl();
        tmp->befehl = abschnitt.getText();
        tmp->befehl.setSuchGrenzen( '(', ')' );
        removeKlammer( &tmp->befehl );
        tmp->debug.datei = dbg->datei.getText();
        tmp->debug.zeile = dbg->zeile;
        tmp->typ = 0;
        bef = new KSGSOperatorBefehl( zObj, tmp, zKT, zFT, zVT, klassName, funktionName );
        delete tmp;
        if( bef->hatFehler() )
            return;
        *typId = bef->getReturnTyp();
    }
    else if( abschnitt.hat( '(' ) )
    { // Funktionsaufruf
        typ = FUNKTION;
        bool b = 0;
        funk = new KSGSBefehlFunktion( zObj, dynamic_cast<Text *>( abschnitt.getThis() ), dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b );
        if( !b )
            return;
    }
    else
    { // Variable
        typ = VARIABLE;
        bool b = 0;
        var = new KSGSBefehlVariable( dynamic_cast<Text *>( abschnitt.getThis() ), zKT, zFT, zVT, klassName, funktionName, typId, &b );
        if( !b )
            return;
    }
    *ok = 1;
}

KSGSBefehlMember::~KSGSBefehlMember()
{
    if( bef )
        bef->release();
    delete funk;
    delete var;
}

KSGSBefehlParameter::KSGSBefehlParameter( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                          KSGSCompVarTable *zVT, const char *klassName, const char *funktionName, int *typId, bool *ok )
{
    *typId = -1;
    *ok = 0;
    Text param = txt->getText();
    param.setSuchGrenzen( '(', ')' );
    removeKlammer( &param );
    txt->release();
    if( !param.getLength() || ( !klassName && !funktionName ) )
        return;
    if( param.getLength() > 2 && param[ 0 ] == '0' && param[ 1 ] == 'x' )
    { // Hex Zahl
        typ = WERT;
        wert = (int)param;
        *typId = zKT->get( "int" )->id;
    }
    else if( param.getLength() == 3 && param[ 0 ] == '\'' && param[ 2 ] == '\'' )
    { // Char
        typ = WERT;
        wert = (int)param[ 1 ];
        *typId = zKT->get( "int" )->id;
    }
    else if( param.getLength() > 1 && param[ 0 ] == '"' && param[ param.getLength() - 1 ] == '"' )
    { // Text
        typ = WERT;
        int anz = param.getLength();
        bool backSlash = 0;
        for( int i = 0; i < anz; i++ )
        {
            if( param[ i ] == '\\' )
            {
                if( backSlash )
                {
                    wert.append( '\\' );
                    backSlash = 0;
                }
                else
                    backSlash = 1;
            }
            else if( backSlash )
            {
                switch( param[ i ] )
                {
                case 'n':
                    wert.append( '\n' );
                    break;
                case 'r':
                    wert.append( '\r' );
                    break;
                case 't':
                    wert.append( '\t' );
                    break;
                case '"':
                    wert.append( '"' );
                    break;
                case '0':
                    wert.append( '\0' );
                    break;
                case '1':
                    wert.append( '\1' );
                    break;
                case '2':
                    wert.append( '\2' );
                    break;
                case '3':
                    wert.append( '\3' );
                    break;
                case '4':
                    wert.append( '\4' );
                    break;
                case '5':
                    wert.append( '\5' );
                    break;
                case '6':
                    wert.append( '\6' );
                    break;
                case '7':
                    wert.append( '\7' );
                    break;
                case '8':
                    wert.append( '\x8' );
                    break;
                case '9':
                    wert.append( '\x9' );
                    break;
                }
                backSlash = 0;
            }
            else
                wert.append( param[ i ] );
        }
        *typId = zKT->get( "Text" )->id;
    }
    else if( param.istGleich( "true" ) )
    { // True
        typ = WERT;
        wert = "true";
        *typId = zKT->get( "Text" )->id;
    }
    else if( param.istGleich( "false" ) )
    { // False
        typ = WERT;
        wert = "false";
        *typId = zKT->get( "Text" )->id;
    }
    else
    {
        bool num = 1;
        bool p = 0;
        bool m = 0;
        for( int i = 0; i < param.getLength(); i++ )
        {
            num &= ( param[ i ] >= '0' && param[ i ] <= '9' ) || param[ i ] == '.' || param[ i ] == '-';
            if( param[ i ] == '.' )
            {
                if( p )
                    num = 0;
                p = 1;
            }
            if( param[ i ] == '-' )
            {
                if( m )
                    num = 0;
                m = 1;
            }
        }
        if( num )
        { // Zahl
            typ = WERT;
            if( !p )
            {
                wert = (int)param;
                *typId = KSGS_INT;
            }
            else
            {
                wert = (double)param;
                *typId = KSGS_DOUBLE;
            }
        }
        else
        { // Objekt
            typ = OBJEKT;
            if( hatOperator( &param ) >= 0 )
            { // Befehl
                bool b = 0;
                KSGSBefehlMember *obj = new KSGSBefehlMember( zObj, dynamic_cast<Text *>( param.getThis() ), dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b );
                if( !b )
                {
                    delete obj;
                    return;
                }
                objekt.add( obj );
            }
            else
            { // Zeichnung Kette
                int abschnittAnz = param.anzahlVon( '.' ) + 1;
                int *abschnittEnde = new int[ abschnittAnz ];
                for( int i = 0; i < abschnittAnz - 1; i++ )
                    abschnittEnde[ i ] = param.positionVon( '.', i );
                abschnittEnde[ abschnittAnz - 1 ] = param.getLength();
                for( int i = 0; i < abschnittAnz; i++ )
                {
                    int beg = 0;
                    if( i > 0 )
                        beg = abschnittEnde[ i - 1 ] + 1;
                    int end = abschnittEnde[ i ];
                    Text *abschnitt = param.getTeilText( beg, end );
                    bool b = 0;
                    KSGSBefehlMember *mem = new KSGSBefehlMember( zObj, abschnitt, dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b );
                    if( !b )
                    {
                        delete mem;
                        delete[] abschnittEnde;
                        return;
                    }
                    objekt.add( mem );
                }
                delete[] abschnittEnde;
            }
        }
    }
    *ok = 1;
}

KSGSBefehlParameter::~KSGSBefehlParameter()
{
    int anz = objekt.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        delete objekt.get( i );
}

KSGSBefehlErstell::KSGSBefehlErstell( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                      KSGSCompVarTable *zVT, const char *klassName, const char *funktionName, bool *ok )
{
    param = 0;
    konstruktor = 0;
    *ok = 0;
    Text text = txt->getText();
    text.setSuchGrenzen( '(', ')' );
    removeKlammer( &text );
    txt->release();
    if( !text.getLength() || ( !klassName && !funktionName ) )
        return;
    KSGSCompFuncTable *zLFT = zFT;
    if( klassName )
        zLFT = &zKT->get( klassName )->funcs;
    Text *typ = text.getTeilText( 0, text.positionVon( ' ' ) );
    typ->setSuchGrenzen( '(', ')' );
    removeKlammer( typ );
    if( !zKT->hat( (char *)*typ ) )
    {
        typ->release();
        return;
    }
    typId = zKT->get( (char *)*typ )->id;
    char endC = 0;
    if( text.hat( '(' ) )
    {
        endC = '(';
        Text *name = text.getTeilText( text.positionVon( ' ' ) + 1, text.positionVon( '(' ) );
        konstruktor = 1;
        Text befehl = name->getText();
        name->release();
        befehl += ".";
        befehl += typ->getText();
        befehl += &text[ text.positionVon( '(' ) ];
        bool b = 0;
        int pTyp = -1;
        param = new KSGSBefehlParameter( zObj, dynamic_cast<Text *>( befehl.getThis() ), dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b );
        if( !b )
        {
            typ->release();
            return;
        }
    }
    else if( text.hat( '=' ) )
    {
        endC = '=';
        konstruktor = 0;
        Text *p = text.getTeilText( text.positionVon( '=' ) + 1 );
        p->setSuchGrenzen( '(', ')' );
        removeKlammer( p );
        bool b = 0;
        int pTyp = -1;
        param = new KSGSBefehlParameter( zObj, p, dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b );
        if( !b )
        {
            typ->release();
            return;
        }
    }
    typ->release();
    Text *name = text.getTeilText( text.positionVon( ' ' ) + 1, endC ? text.positionVon( endC ) : text.getLength() );
    name->setSuchGrenzen( '(', ')' );
    removeKlammer( name );
    if( zLFT->get( funktionName )->vars.hat( *name ) )
    {
        name->release();
        return;
    }
    zLFT->get( funktionName )->vars.addVariable( *name, new KSGSCompileVariable( typId, 3 ) );
    id = zLFT->get( funktionName )->vars.get( *name )->id;
    name->release();
    *ok = 1;
}

KSGSBefehlErstell::~KSGSBefehlErstell()
{
    delete param;
}


// Inhalt der KSGSBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSBefehl::KSGSBefehl( Typ typ )
    : ReferenceCounter()
{
    this->typ = typ;
    fehler = 0;
    returnTyp = -1;
}

// Destruktor
KSGSBefehl::~KSGSBefehl()
{

}

// constant
KSGSVariable *KSGSBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    return 0;
}

bool KSGSBefehl::hatFehler() const
{
    return fehler;
}

int KSGSBefehl::getReturnTyp() const
{
    return returnTyp;
}

bool KSGSBefehl::istTyp( Typ t ) const
{
    return typ == t;
}

// static
KSGSVariable *KSGSBefehl::prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
{
    if( !zVar )
    {
        error( 22, {}, zObj );
        return 0;
    }
    switch( zVar->varSichtbar )
    {
    case 0: // public
        if( !zVorObj )
            return zObj->getVariable( zVar->varId );
        break;
    case 1: // public in Klasse
        if( zVorObj )
            return zVorObj->getVariable( zVar->varId, 0 );
        else if( zKI )
            return zKI->getVariable( zVar->varId, 1 );
        break;
    case 2: // privat in Klasse
        if( zKI && !zVorObj )
            return zKI->getVariable( zVar->varId, 1 );
        break;
    case 3: // lokal in Funktion
        if( !zVorObj && zFI )
            return zFI->getVariable( zVar->varId );
        break;
    }
    error( 22, {}, zObj );
    return 0;
}

KSGSVariable *KSGSBefehl::prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunktion *zFunk, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
{
    if( !zFunk )
    {
        error( 22, {}, zObj );
        return 0;
    }
    RCArray< KSGSVariable > *parameter = new RCArray< KSGSVariable >();
    int pAnz = zFunk->parameter.getEintragAnzahl();
    for( int i = 0; i < pAnz; i++ )
        parameter->set( prozessParameter( zFunk->parameter.get( i ), zObj, zFI, zKI ), i );
    switch( zFunk->funkSichtbar )
    {
    case 0: // public
        if( !zVorObj )
            return zObj->startFunktion( zFunk->funcId, parameter );
        break;
    case 1: // public in Klasse
        if( zVorObj )
            return zVorObj->startFunktion( zFunk->funcId, 0, parameter );
        else if( zKI )
            return zKI->startFunktion( zFunk->funcId, 1, parameter );
        break;
    case 2: // privat in Klasse
        if( zKI && !zVorObj )
            return zKI->startFunktion( zFunk->funcId, 1, parameter );
        break;
    }
    parameter->release();
    error( 22, {}, zObj );
    return 0;
}

KSGSVariable *KSGSBefehl::prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember *zMem, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
{
    if( !zMem )
    {
        error( 22, {}, zObj );
        return 0;
    }
    switch( zMem->typ )
    {
    case KSGSBefehlMember::BEFEHL:
        if( !zVorObj && zMem->bef )
            return zMem->bef->execute( zObj, zFI, zKI );
        break;
    case KSGSBefehlMember::FUNKTION:
        if( zMem->funk )
            return prozessFunktion( zVorObj, zMem->funk, zObj, zFI, zKI );
        break;
    case KSGSBefehlMember::VARIABLE:
        if( zMem->var )
            return prozessVariable( zVorObj, zMem->var, zObj, zFI, zKI );
        break;
    }
    error( 22, {}, zObj );
    return 0;
}

KSGSVariable *KSGSBefehl::prozessParameter( KSGSBefehlParameter *zParam, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
{
    if( !zParam )
    {
        error( 22, {}, zObj );
        return 0;
    }
    switch( zParam->typ )
    {
    case KSGSBefehlParameter::WERT:
        if( zParam->wert.getLength() )
        {
            if( !zParam->wert.positionVon( "0x" ) )
                return new KSGSIntKlasse( zObj, zParam->wert );
            if( zParam->wert.istGleich( "true" ) )
                return new KSGSBoolKlasse( zObj, 1 );
            if( zParam->wert.istGleich( "false" ) )
                return new KSGSBoolKlasse( zObj, 0 );
            int anz = zParam->wert.getLength();
            bool p = 0;
            bool num = 1;
            bool m = 0;
            for( int i = 0; i < anz; i++ )
            {
                num &= ( zParam->wert[ i ] >= '0' && zParam->wert[ i ] <= '9' ) || zParam->wert[ i ] == '.' || zParam->wert[ i ] == '-';
                if( zParam->wert[ i ] == '.' )
                {
                    if( p )
                        num = 0;
                    p = 1;
                }
                if( zParam->wert[ i ] == '-' )
                {
                    if( m )
                        num = 0;
                    m = 1;
                }
            }
            if( num )
            {
                if( p )
                    return new KSGSDoubleKlasse( zObj, zParam->wert );
                else
                    return new KSGSIntKlasse( zObj, zParam->wert );
            }
            if( !zParam->wert.positionVon( '"' ) && zParam->wert.positionVon( '"', zParam->wert.anzahlVon( '"' ) - 1 ) == anz - 1 )
            {
                Text *txt = zParam->wert.getTeilText( 1, anz - 1 );
                KSGSVariable *ret = new KSGSTextKlasse( zObj, *txt );
                txt->release();
                return ret;
            }
            if( anz == 3 && zParam->wert[ 0 ] == '\'' && zParam->wert[ 2 ] == '\'' )
                return new KSGSIntKlasse( zObj, zParam->wert[ 1 ] );
        }
        break;
    case KSGSBefehlParameter::OBJEKT:
        if( zParam->objekt.getEintragAnzahl() )
        {
            KSGSVariable *v = 0;
            int anz = zParam->objekt.getEintragAnzahl();
            for( int i = 0; i < anz; i++ )
            {
                KSGSVariable *tmp = prozessMember( v, zParam->objekt.get( i ), zObj, zFI, zKI );
                if( v )
                    v->release();
                v = tmp;
            }
            return v;
        }
        break;
    }
    error( 22, {}, zObj );
    return 0;
}

KSGSVariable *KSGSBefehl::prozessErstell( KSGSBefehlErstell *zErst, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
{
    if( !zErst )
    {
        error( 22, {}, zObj );
        return 0;
    }
    KSGSVariable *ret = 0;
    if( zErst->param )
        ret = prozessParameter( zErst->param, zObj, zFI, zKI );
    if( !ret )
    {
        KSGSVariableDef def = { zErst->typId, zErst->id, 3, "" };
        ret = KSGSKlasseInstanz::erstellVariable( zObj, &def );
    }
    if( !ret )
    {
        error( 22, {}, zObj );
        return 0;
    }
    if( ret->getTyp() != zErst->typId )
    {
        KSGSVariable *tmp = ret->umwandelnIn( zErst->typId );
        ret->release();
        ret = tmp;
    }
    zFI->setVariable( zErst->id, dynamic_cast<KSGSVariable *>( ret->getThis() ) );
    return ret;
}


// Inhalt der KSGSCallBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSCallBefehl::KSGSCallBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::CALL )
{
    removeKlammer( &bef->befehl );
    int abschnittAnz = bef->befehl.anzahlVon( '.' ) + 1;
    int *abschnittEnde = new int[ abschnittAnz ];
    for( int i = 0; i < abschnittAnz - 1; i++ )
        abschnittEnde[ i ] = bef->befehl.positionVon( '.', i );
    abschnittEnde[ abschnittAnz - 1 ] = bef->befehl.getLength();
    int vTyp = -1;
    for( int i = 0; i < abschnittAnz; i++ )
    {
        int beg = 0;
        if( i > 0 )
            beg = abschnittEnde[ i - 1 ] + 1;
        int end = abschnittEnde[ i ];
        Text *abschnitt = bef->befehl.getTeilText( beg, end );
        bool b = 0;
        KSGSBefehlMember *mem = new KSGSBefehlMember( zObj, dynamic_cast<Text *>( abschnitt->getThis() ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &vTyp, &b );
        if( !b )
        {
            error( 13, { bef->debug.datei, Text() += bef->debug.zeile, *abschnitt }, zObj );
            abschnitt->release();
            delete mem;
            delete[] abschnittEnde;
            fehler = 1;
            return;
        }
        abschnitt->release();
        objekt.add( mem );
    }
    delete[] abschnittEnde;
    returnTyp = vTyp;
}

// Destruktor
KSGSCallBefehl::~KSGSCallBefehl()
{
    int anz = objekt.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        delete objekt.get( i );
}

// constant
KSGSVariable *KSGSCallBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    KSGSVariable *v = 0;
    int anz = objekt.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        KSGSVariable *tmp = prozessMember( v, objekt.get( i ), zObj, zFI, zKI );
        if( v )
            v = (KSGSVariable *)v->release();
        v = tmp;
    }
    return v;
}


// Inhalt der KSGSOperatorBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSOperatorBefehl::KSGSOperatorBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                        KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::OPERATOR )
{
    paramL = 0;
    paramR = 0;
    removeKlammer( &bef->befehl );
    operatorId = hatOperator( &bef->befehl );
    if( operatorId < 0 )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
        fehler = 1;
        return;
    }
    int opLen = 0;
    int opPos = getOperatorPos( &bef->befehl, &opLen );
    Text *links = bef->befehl.getTeilText( 0, opPos );
    bool b = 0;
    paramL = new KSGSBefehlParameter( zObj, links, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &returnTyp, &b );
    if( !b )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
        fehler = 1;
        return;
    }
    Text *rechts = bef->befehl.getTeilText( opPos + opLen );
    b = 0;
    int rTyp = -1;
    paramR = new KSGSBefehlParameter( zObj, rechts, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &rTyp, &b );
    if( !b )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
        fehler = 1;
        return;
    }
    if( operatorId >= 7 && operatorId <= 14 )
        returnTyp = zKT->get( "bool" )->id;
}

// Destruktor
KSGSOperatorBefehl::~KSGSOperatorBefehl()
{
    delete paramL;
    delete paramR;
}

// constant
KSGSVariable *KSGSOperatorBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    KSGSVariable *l = prozessParameter( paramL, zObj, zFI, zKI );
    if( operatorId == KSGS_O_SET && ( l ? l->getTyp() > KSGS_TYP_MAX : 1 ) )
    {
        if( l )
            l->release();
        if( !paramL || !paramR )
        {
            error( 22, {}, zObj );
            return 0;
        }
        KSGSVariable *lVObj = 0;
        int vId = 0;
        int vS = 0;
        switch( paramL->typ )
        {
        case KSGSBefehlParameter::WERT:
            error( 22, {}, zObj );
            return 0;
        case KSGSBefehlParameter::OBJEKT:
            if( paramL->objekt.getEintragAnzahl() )
            {
                KSGSVariable *v = 0;
                int anz = paramL->objekt.getEintragAnzahl();
                for( int i = 0; i < anz; i++ )
                {
                    if( lVObj )
                        lVObj->release();
                    lVObj = v ? dynamic_cast<KSGSVariable *>( v->getThis() ) : 0;
                    KSGSVariable *tmp = 0;
                    switch( paramL->objekt.get( i )->typ )
                    {
                    case KSGSBefehlMember::BEFEHL:
                        if( i == anz - 1 )
                        {
                            error( 22, {}, zObj );
                            if( v )
                                v->release();
                            if( lVObj )
                                lVObj->release();
                            return 0;
                        }
                        if( !v && paramL->objekt.get( i )->bef )
                            tmp = paramL->objekt.get( i )->bef->execute( zObj, zFI, zKI );
                        break;
                    case KSGSBefehlMember::FUNKTION:
                        if( i == anz - 1 )
                        {
                            error( 22, {}, zObj );
                            if( v )
                                v->release();
                            if( lVObj )
                                lVObj->release();
                            return 0;
                        }
                        if( paramL->objekt.get( i )->funk )
                            tmp = prozessFunktion( v, paramL->objekt.get( i )->funk, zObj, zFI, zKI );
                        break;
                    case KSGSBefehlMember::VARIABLE:
                        vId = paramL->objekt.get( i )->var->varId;
                        vS = paramL->objekt.get( i )->var->varSichtbar;
                        if( paramL->objekt.get( i )->var )
                            tmp = prozessVariable( v, paramL->objekt.get( i )->var, zObj, zFI, zKI );
                        break;
                    }
                    if( v )
                        v->release();
                    v = tmp;
                }
                if( v )
                    v->release();
            }
            break;
        default:
            error( 22, {}, zObj );
            return 0;
        }
        KSGSVariable *r = paramR ? prozessParameter( paramR, zObj, zFI, zKI ) : 0;
        if( !r )
        {
            if( lVObj )
                lVObj->release();
            error( 22, {}, zObj );
            return 0;
        }
        if( vS == 3 ) // Funktionsvariable
        {
            if( lVObj )
                lVObj->release();
            zFI->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
            return r;
        }
        else if( !vS ) // Scriptvariable
        {
            if( lVObj )
                lVObj->release();
            zObj->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
            return r;
        }
        else // Klassenvariable
        {
            if( !lVObj )
            {
                zKI->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
                return r;
            }
            lVObj->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
            if( lVObj )
                lVObj->release();
            return r;
        }
    }
    if( !l )
        return 0;
    KSGSVariable *r = paramR ? prozessParameter( paramR, zObj, zFI, zKI ) : 0;
    KSGSVariable *ret = l->doOperator( operatorId, r );
    if( l )
        l->release();
    return ret;
}


// Inhalt der KSGSIfBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSIfBefehl::KSGSIfBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                            KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::IF )
{
    bedingung = 0;
    int bTyp = -1;
    bool b = 0;
    bedingung = new KSGSBefehlParameter( zObj, dynamic_cast<Text *>( bef->befehl.getThis() ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b );
    int anz = bef->listA.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        KSGSLeseBefehl *b = bef->listA.get( i );
        KSGSBefehl *ret = 0;
        switch( b->typ )
        {
        case 0: // call oder operator
            if( 1 )
            {
                removeKlammer( &b->befehl );
                b->befehl.setSuchGrenzen( '(', ')' );
                if( hatOperator( &b->befehl ) >= 0 )
                    ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
                else
                    ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            }
            break;
        case 3: // var
            ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 6: // if
            ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 7: // for
            ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 8: // while
            ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 9: // return
            ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 10: // break
            ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 11: // continue
            ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        }
        if( !ret )
            error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
        if( ret && ret->hatFehler() )
            ret = (KSGSBefehl *)ret->release();
        if( !ret )
        {
            fehler = 1;
            return;
        }
        bTrue.add( ret );
    }
    anz = bef->listB.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        KSGSLeseBefehl *b = bef->listB.get( i );
        KSGSBefehl *ret = 0;
        switch( b->typ )
        {
        case 0: // call oder operator
            if( 1 )
            {
                removeKlammer( &b->befehl );
                b->befehl.setSuchGrenzen( '(', ')' );
                if( hatOperator( &b->befehl ) >= 0 )
                    ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
                else
                    ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            }
            break;
        case 3: // var
            ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 6: // if
            ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 7: // for
            ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 8: // while
            ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 9: // return
            ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 10: // break
            ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 11: // continue
            ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        }
        if( !ret )
            error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
        if( ret && ret->hatFehler() )
            ret = (KSGSBefehl *)ret->release();
        if( !ret )
        {
            fehler = 1;
            return;
        }
        bFalse.add( ret );
    }
}

// Destruktor
KSGSIfBefehl::~KSGSIfBefehl()
{
    delete bedingung;
}

// constant
KSGSVariable *KSGSIfBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
    if( !b )
        return 0;
    if( b->getBool() )
    {
        int anz = bTrue.getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
        {
            while( zFI->getStatus() == 1 ) // pause
                Sleep( 100 );
            if( !zFI->getStatus() ) // return
                break;
            KSGSVariable *v = bTrue.z( i )->execute( zObj, zFI, zKI );
            if( v )
                v->release();
        }
    }
    else
    {
        int anz = bFalse.getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
        {
            while( zFI->getStatus() == 1 ) // pause
                Sleep( 100 );
            if( !zFI->getStatus() ) // return
                break;
            KSGSVariable *v = bFalse.z( i )->execute( zObj, zFI, zKI );
            if( v )
                v->release();
        }
    }
    b->release();
    return 0;
}


// Inhalt der KSGSForBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSForBefehl::KSGSForBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                              KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::FOR )
{
    links = 0;
    rechts = 0;
    bedingung = 0;
    Text klammer = bef->befehl.getText();
    klammer.setSuchGrenzen( '(', ')' );
    removeKlammer( &klammer );
    if( klammer.anzahlVon( ';' ) != 2 )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, klammer }, zObj );
        fehler = 1;
        return;
    }
    Text *l = klammer.getTeilText( 0, klammer.positionVon( ';' ) );
    l->setSuchGrenzen( '(', ')' );
    removeKlammer( l );
    KSGSLeseBefehl *b = new KSGSLeseBefehl();
    b->debug.datei = bef->debug.datei.getText();
    b->debug.zeile = bef->debug.zeile;
    b->befehl = l->getText();
    l->release();
    if( !b->befehl.positionVon( "var" ) )
        links = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
    else if( hatOperator( &b->befehl ) >= 0 )
        links = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
    else if( b->befehl.getLength() )
        links = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
    delete b;
    if( links && links->hatFehler() )
    {
        fehler = 1;
        return;
    }
    Text *bed = klammer.getTeilText( klammer.positionVon( ';' ) + 1, klammer.positionVon( ';', 1 ) );
    bed->setSuchGrenzen( '(', ')' );
    removeKlammer( bed );
    if( bed->getLength() )
    {
        int bTyp = -1;
        bool b = 0;
        bedingung = new KSGSBefehlParameter( zObj, bed, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b );
        if( !b )
        {
            error( 13, { bef->debug.datei, Text() += bef->debug.zeile, klammer }, zObj );
            fehler = 1;
            return;
        }
    }
    else
        bed->release();
    Text *r = klammer.getTeilText( klammer.positionVon( ';', 1 ) + 1 );
    r->setSuchGrenzen( '(', ')' );
    removeKlammer( r );
    b = new KSGSLeseBefehl();
    b->debug.datei = bef->debug.datei.getText();
    b->debug.zeile = bef->debug.zeile;
    b->befehl = r->getText();
    r->release();
    if( hatOperator( &b->befehl ) >= 0 )
        rechts = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
    else if( b->befehl.getLength() )
        rechts = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
    delete b;
    if( rechts && rechts->hatFehler() )
    {
        fehler = 1;
        return;
    }
    int anz = bef->listA.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        KSGSLeseBefehl *b = bef->listA.get( i );
        KSGSBefehl *ret = 0;
        switch( b->typ )
        {
        case 0: // call oder operator
            if( 1 )
            {
                removeKlammer( &b->befehl );
                b->befehl.setSuchGrenzen( '(', ')' );
                if( hatOperator( &b->befehl ) >= 0 )
                    ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
                else
                    ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            }
            break;
        case 3: // var
            ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 6: // if
            ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 7: // for
            ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 8: // while
            ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 9: // return
            ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 10: // break
            ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 11: // continue
            ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        }
        if( !ret )
            error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
        if( ret && ret->hatFehler() )
            ret = (KSGSBefehl *)ret->release();
        if( !ret )
        {
            fehler = 1;
            return;
        }
        schleife.add( ret );
    }
}

// Destruktor
KSGSForBefehl::~KSGSForBefehl()
{
    if( links )
        links->release();
    if( rechts )
        rechts->release();
    delete bedingung;
}

// constant
KSGSVariable *KSGSForBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    KSGSVariable *l = links ? links->execute( zObj, zFI, zKI ) : 0;
    if( l )
        l->release();
    KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
    if( !b )
        return 0;
    int anz = schleife.getEintragAnzahl();
    while( b->getBool() )
    {
        for( int i = 0; i < anz; i++ )
        {
            while( zFI->getStatus() == 1 ) // pause
                Sleep( 100 );
            if( !zFI->getStatus() ) // return
                break;
            if( zFI->getStatus() == 2 ) // continue
                break;
            KSGSVariable *v = schleife.z( i )->execute( zObj, zFI, zKI );
            if( v )
                v->release();
        }
        if( zFI->getStatus() == 3 ) // break
            break;
        while( zFI->getStatus() == 1 ) // pause
            Sleep( 100 );
        if( !zFI->getStatus() ) // return
            break;
        if( !anz )
            Sleep( 100 );
        KSGSVariable *v = rechts ? rechts->execute( zObj, zFI, zKI ) : 0;
        if( v )
            v->release();
        if( b )
            b->release();
        b = prozessParameter( bedingung, zObj, zFI, zKI );
        if( !b )
            return 0;
    }
    b->release();
    return 0;
}


// Inhalt der KSGSWhileBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSWhileBefehl::KSGSWhileBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                  KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::WHILE )
{
    bedingung = 0;
    int bTyp = -1;
    bool b = 0;
    bedingung = new KSGSBefehlParameter( zObj, dynamic_cast<Text *>( bef->befehl.getThis() ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b );
    int anz = bef->listA.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        KSGSLeseBefehl *b = bef->listA.get( i );
        KSGSBefehl *ret = 0;
        switch( b->typ )
        {
        case 0: // call oder operator
            if( 1 )
            {
                removeKlammer( &b->befehl );
                b->befehl.setSuchGrenzen( '(', ')' );
                if( hatOperator( &b->befehl ) >= 0 )
                    ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
                else
                    ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            }
            break;
        case 3: // var
            ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 6: // if
            ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 7: // for
            ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 8: // while
            ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 9: // return
            ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 10: // break
            ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        case 11: // continue
            ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
            break;
        }
        if( !ret )
            error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
        if( ret && ret->hatFehler() )
            ret = (KSGSBefehl *)ret->release();
        if( !ret )
        {
            fehler = 1;
            return;
        }
        schleife.add( ret );
    }
}

// Destruktor
KSGSWhileBefehl::~KSGSWhileBefehl()
{
    delete bedingung;
}

// constant
KSGSVariable *KSGSWhileBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
    if( !b )
        return 0;
    int anz = schleife.getEintragAnzahl();
    while( b->getBool() )
    {
        for( int i = 0; i < anz; i++ )
        {
            while( zFI->getStatus() == 1 ) // pause
                Sleep( 100 );
            if( !zFI->getStatus() ) // return
                break;
            if( zFI->getStatus() == 2 ) // continue
                break;
            KSGSVariable *v = schleife.z( i )->execute( zObj, zFI, zKI );
            if( v )
                v->release();
        }
        if( zFI->getStatus() == 3 ) // break
            break;
        while( zFI->getStatus() == 1 ) // pause
            Sleep( 100 );
        if( !zFI->getStatus() ) // return
            break;
        if( !anz )
            Sleep( 100 );
        if( b )
            b->release();
        b = prozessParameter( bedingung, zObj, zFI, zKI );
        if( !b )
            return 0;
    }
    b->release();
    return 0;
}


// Inhalt der KSGSReturnBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSReturnBefehl::KSGSReturnBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                    KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::RETURN )
{
    param = 0;
    if( bef->befehl.positionVon( "return" ) != 0 )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
        fehler = 1;
        return;
    }
    bool b = 0;
    param = new KSGSBefehlParameter( zObj, bef->befehl.getTeilText( 6 ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &returnTyp, &b );
    if( !b )
    {
        delete param;
        param = 0;
    }
}

// Destruktor
KSGSReturnBefehl::~KSGSReturnBefehl()
{
    delete param;
}

// constant
KSGSVariable *KSGSReturnBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    KSGSVariable *v = param ? prozessParameter( param, zObj, zFI, zKI ) : 0;
    if( v )
        zFI->setReturnVariable( v );
    zFI->setEnde();
    return 0;
}


// Inhalt der KSGSBreakBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSBreakBefehl::KSGSBreakBefehl( KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                  KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::BREAK )
{}

// Destruktor
KSGSBreakBefehl::~KSGSBreakBefehl()
{

}

// constant
KSGSVariable *KSGSBreakBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    zFI->setBreak();
    return 0;
}


// Inhalt der KSGSContinueBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSContinueBefehl::KSGSContinueBefehl( KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                        KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::CONTINUE )
{}

// Destruktor
KSGSContinueBefehl::~KSGSContinueBefehl()
{

}

// constant
KSGSVariable *KSGSContinueBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    zFI->setContinue();
    return 0;
}


// Inhalt der KSGSVariableBefehl Klasse aus KSGSBefehl.h
// Konstruktor
KSGSVariableBefehl::KSGSVariableBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
                                        KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
    : KSGSBefehl( Typ::VARIABLE )
{
    erstell = 0;
    if( bef->befehl.positionVon( "var" ) != 0 )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
        fehler = 1;
        return;
    }
    bool b = 0;
    erstell = new KSGSBefehlErstell( zObj, bef->befehl.getTeilText( 3 ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &b );
    returnTyp = erstell->typId;
    if( !b )
    {
        error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
        fehler = 1;
        return;
    }
}

// Destruktor
KSGSVariableBefehl::~KSGSVariableBefehl()
{
    delete erstell;
}

// constant
KSGSVariable *KSGSVariableBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
{
    return prozessErstell( erstell, zObj, zFI, zKI );
}