framework changes

ksgScript/Befehl/KSGSBefehl.cpp

@@ -13,508 +13,508 @@
 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 )
+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;
+	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 )
+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;
+	*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 );
+	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 )
+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;
+	*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;
+	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 )
+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;
+	*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 );
+	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 )
+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;
+	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((const char*)*typ))
+	{
+		typ->release();
+		return;
+	}
+	typId = zKT->get((const 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;
+	delete param;
 }
 
 
 // Inhalt der KSGSBefehl Klasse aus KSGSBefehl.h
 // Konstruktor
-KSGSBefehl::KSGSBefehl( Typ typ )
-    : ReferenceCounter()
+KSGSBefehl::KSGSBefehl(Typ typ)
+	: ReferenceCounter()
 {
-    this->typ = typ;
-    fehler = 0;
-    returnTyp = -1;
+	this->typ = typ;
+	fehler = 0;
+	returnTyp = -1;
 }
 
 // Destruktor
@@ -524,953 +524,953 @@ KSGSBefehl::~KSGSBefehl()
 }
 
 // constant
-KSGSVariable *KSGSBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+KSGSVariable* KSGSBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
 {
-    return 0;
+	return 0;
 }
 
 bool KSGSBefehl::hatFehler() const
 {
-    return fehler;
+	return fehler;
 }
 
 int KSGSBefehl::getReturnTyp() const
 {
-    return returnTyp;
+	return returnTyp;
 }
 
-bool KSGSBefehl::istTyp( Typ t ) const
+bool KSGSBefehl::istTyp(Typ t) const
 {
-    return typ == t;
+	return typ == t;
 }
 
 // static
-KSGSVariable *KSGSBefehl::prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
+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;
+	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 )
+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;
+	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 )
+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;
+	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 )
+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;
+	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, (int)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, (double)zParam->wert);
+				else
+					return new KSGSIntKlasse(zObj, (int)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 )
+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;
+	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 )
+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;
+	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 );
+	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* 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;
+	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 )
+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;
+	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;
+	delete paramL;
+	delete paramR;
 }
 
 // constant
-KSGSVariable *KSGSOperatorBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+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;
+	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 )
+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 );
-    }
+	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;
+	delete bedingung;
 }
 
 // constant
-KSGSVariable *KSGSIfBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+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;
+	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 )
+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 );
-    }
+	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;
+	if (links)
+		links->release();
+	if (rechts)
+		rechts->release();
+	delete bedingung;
 }
 
 // constant
-KSGSVariable *KSGSForBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+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;
+	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 )
+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 );
-    }
+	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;
+	delete bedingung;
 }
 
 // constant
-KSGSVariable *KSGSWhileBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+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;
+	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 )
+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;
-    }
+	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;
+	delete param;
 }
 
 // constant
-KSGSVariable *KSGSReturnBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+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;
+	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 )
+KSGSBreakBefehl::KSGSBreakBefehl(KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
+	KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
+	: KSGSBefehl(Typ::BREAK)
 {}
 
 // Destruktor
@@ -1480,18 +1480,18 @@ KSGSBreakBefehl::~KSGSBreakBefehl()
 }
 
 // constant
-KSGSVariable *KSGSBreakBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+KSGSVariable* KSGSBreakBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
 {
-    zFI->setBreak();
-    return 0;
+	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 )
+KSGSContinueBefehl::KSGSContinueBefehl(KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
+	KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
+	: KSGSBefehl(Typ::CONTINUE)
 {}
 
 // Destruktor
@@ -1501,45 +1501,45 @@ KSGSContinueBefehl::~KSGSContinueBefehl()
 }
 
 // constant
-KSGSVariable *KSGSContinueBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+KSGSVariable* KSGSContinueBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
 {
-    zFI->setContinue();
-    return 0;
+	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 )
+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;
-    }
+	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;
+	delete erstell;
 }
 
 // constant
-KSGSVariable *KSGSVariableBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
+KSGSVariable* KSGSVariableBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
 {
-    return prozessErstell( erstell, zObj, zFI, zKI );
+	return prozessErstell(erstell, zObj, zFI, zKI);
 }

ksgScript/Befehl/KSGSKlasse.cpp

@@ -21,451 +21,451 @@ using namespace KSGScript;
 
 // Inhalt der KSGSKlasseInstanz Klasse aus KSGSKlasse.h
 // Konstruktor
-KSGSKlasseInstanz::KSGSKlasseInstanz( int typ, Array< KSGSVariableDef * > *zVars, RCArray< KSGSFunktion > *funcs, KSGScriptProcessor *zObj )
-    : ReferenceCounter()
+KSGSKlasseInstanz::KSGSKlasseInstanz(int typ, Array< KSGSVariableDef* >* zVars, RCArray< KSGSFunktion >* funcs, KSGScriptProcessor* zObj)
+	: ReferenceCounter()
 {
-    lokaleVariablen = new RCArray< KSGSVariable >();
-    varPublic = new Array< bool >();
-    funktionen = funcs;
-    obj = zObj;
-    lokaleVariablen->add( dynamic_cast<KSGSKlasseInstanz *>( getThis() ), 0 );
-    varPublic->set( 0, 0 );
-    int anz = zVars ? zVars->getEintragAnzahl() : 0;
-    for( int i = 0; i < anz; i++ )
-    {
-        lokaleVariablen->set( KSGSKlasseInstanz::erstellVariable( zObj, zVars->get( i ) ), zVars->get( i )->id + 1 );
-        varPublic->set( zVars->get( i )->sichtbar == 1, zVars->get( i )->id + 1 );
-    }
-    this->typ = typ;
+	lokaleVariablen = new RCArray< KSGSVariable >();
+	varPublic = new Array< bool >();
+	funktionen = funcs;
+	obj = zObj;
+	lokaleVariablen->add(dynamic_cast<KSGSKlasseInstanz*>(getThis()), 0);
+	varPublic->set(0, 0);
+	int anz = zVars ? zVars->getEintragAnzahl() : 0;
+	for (int i = 0; i < anz; i++)
+	{
+		lokaleVariablen->set(KSGSKlasseInstanz::erstellVariable(zObj, zVars->get(i)), zVars->get(i)->id + 1);
+		varPublic->set(zVars->get(i)->sichtbar == 1, zVars->get(i)->id + 1);
+	}
+	this->typ = typ;
 }
 
 // Destruktor
 KSGSKlasseInstanz::~KSGSKlasseInstanz()
 {
-    lokaleVariablen->release();
-    if( funktionen )
-        funktionen->release();
-    varPublic->release();
+	lokaleVariablen->release();
+	if (funktionen)
+		funktionen->release();
+	varPublic->release();
 }
 
 // nicht constant
-KSGSVariable *KSGSKlasseInstanz::startFunktion( int id, bool zugriff, RCArray< KSGSVariable > *parameter )
+KSGSVariable* KSGSKlasseInstanz::startFunktion(int id, bool zugriff, RCArray< KSGSVariable >* parameter)
 {
-    if( !funktionen || ( !zugriff && ( !funktionen->z( id ) || funktionen->z( id )->getSichtbarkeit() != 1 ) ) )
-    {
-        error( 18, {}, obj );
-        parameter->release();
-        return 0;
-    }
-    if( !funktionen->z( id ) )
-    {
-        parameter->release();
-        return 0;
-    }
-    KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( obj, dynamic_cast<KSGSKlasseInstanz *>( getThis() ), parameter );
-    KSGSVariable *ret = inst->startFunktion();
-    inst->release();
-    return ret;
+	if (!funktionen || (!zugriff && (!funktionen->z(id) || funktionen->z(id)->getSichtbarkeit() != 1)))
+	{
+		error(18, {}, obj);
+		parameter->release();
+		return 0;
+	}
+	if (!funktionen->z(id))
+	{
+		parameter->release();
+		return 0;
+	}
+	KSGSFunktionInstanz* inst = funktionen->z(id)->erstellInstanz(obj, dynamic_cast<KSGSKlasseInstanz*>(getThis()), parameter);
+	KSGSVariable* ret = inst->startFunktion();
+	inst->release();
+	return ret;
 }
 
-KSGSVariable *KSGSKlasseInstanz::doOperator( int id, KSGSVariable *rechts )
+KSGSVariable* KSGSKlasseInstanz::doOperator(int id, KSGSVariable* rechts)
 {
-    error( 21, {}, obj );
-    if( rechts )
-        rechts->release();
-    return 0;
+	error(21, {}, obj);
+	if (rechts)
+		rechts->release();
+	return 0;
 }
 
-void KSGSKlasseInstanz::setVariable( int id, KSGSVariable *var )
+void KSGSKlasseInstanz::setVariable(int id, KSGSVariable* var)
 {
-    lokaleVariablen->set( var, id );
+	lokaleVariablen->set(var, id);
 }
 
 // constant
-KSGSVariable *KSGSKlasseInstanz::getVariable( int id, bool zugriff ) const
+KSGSVariable* KSGSKlasseInstanz::getVariable(int id, bool zugriff) const
 {
-    if( !zugriff && ( !varPublic->hat( id ) || !varPublic->get( id ) ) )
-    {
-        error( 17, {}, obj );
-        return 0;
-    }
-    return lokaleVariablen->get( id );
+	if (!zugriff && (!varPublic->hat(id) || !varPublic->get(id)))
+	{
+		error(17, {}, obj);
+		return 0;
+	}
+	return lokaleVariablen->get(id);
 }
 
-KSGSVariable *KSGSKlasseInstanz::umwandelnIn( int typ ) const
+KSGSVariable* KSGSKlasseInstanz::umwandelnIn(int typ) const
 {
-    error( 16, {}, obj );
-    return 0;
+	error(16, {}, obj);
+	return 0;
 }
 
 int KSGSKlasseInstanz::getTyp() const
 {
-    return typ;
+	return typ;
 }
 
 // verarbeiten
 bool KSGSKlasseInstanz::getBool() const
 {
-    if( typ == KSGS_BOOL )
-        return ( (KSGSBoolKlasse *)this )->getVal();
-    else
-    {
-        KSGSBoolKlasse *tmp = (KSGSBoolKlasse *)umwandelnIn( KSGS_BOOL );
-        if( tmp )
-        {
-            bool ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return 0;
-    }
+	if (typ == KSGS_BOOL)
+		return ((KSGSBoolKlasse*)this)->getVal();
+	else
+	{
+		KSGSBoolKlasse* tmp = (KSGSBoolKlasse*)umwandelnIn(KSGS_BOOL);
+		if (tmp)
+		{
+			bool ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return 0;
+	}
 }
 
 int KSGSKlasseInstanz::getInt() const
 {
-    if( typ == KSGS_INT )
-        return ( (KSGSIntKlasse *)this )->getVal();
-    else
-    {
-        KSGSIntKlasse *tmp = (KSGSIntKlasse *)umwandelnIn( KSGS_INT );
-        if( tmp )
-        {
-            int ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return 0;
-    }
+	if (typ == KSGS_INT)
+		return ((KSGSIntKlasse*)this)->getVal();
+	else
+	{
+		KSGSIntKlasse* tmp = (KSGSIntKlasse*)umwandelnIn(KSGS_INT);
+		if (tmp)
+		{
+			int ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return 0;
+	}
 }
 
 double KSGSKlasseInstanz::getDouble() const
 {
-    if( typ == KSGS_DOUBLE )
-        return ( (KSGSDoubleKlasse *)this )->getVal();
-    else
-    {
-        KSGSDoubleKlasse *tmp = (KSGSDoubleKlasse *)umwandelnIn( KSGS_DOUBLE );
-        if( tmp )
-        {
-            double ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return 0;
-    }
+	if (typ == KSGS_DOUBLE)
+		return ((KSGSDoubleKlasse*)this)->getVal();
+	else
+	{
+		KSGSDoubleKlasse* tmp = (KSGSDoubleKlasse*)umwandelnIn(KSGS_DOUBLE);
+		if (tmp)
+		{
+			double ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return 0;
+	}
 }
 
-Text *KSGSKlasseInstanz::getText() const
+Text* KSGSKlasseInstanz::getText() const
 {
-    if( typ == KSGS_TEXT )
-        return ( (KSGSTextKlasse *)this )->getVal();
-    else
-    {
-        KSGSTextKlasse *tmp = (KSGSTextKlasse *)umwandelnIn( KSGS_TEXT );
-        if( tmp )
-        {
-            Text *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new Text( "" );
-    }
+	if (typ == KSGS_TEXT)
+		return ((KSGSTextKlasse*)this)->getVal();
+	else
+	{
+		KSGSTextKlasse* tmp = (KSGSTextKlasse*)umwandelnIn(KSGS_TEXT);
+		if (tmp)
+		{
+			Text* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new Text("");
+	}
 }
 
-Bild *KSGSKlasseInstanz::getBild() const
+Bild* KSGSKlasseInstanz::getBild() const
 {
-    if( typ == KSGS_BILD )
-        return ( (KSGSBildKlasse *)this )->getVal();
-    else
-    {
-        KSGSBildKlasse *tmp = (KSGSBildKlasse *)umwandelnIn( KSGS_BILD );
-        if( tmp )
-        {
-            Bild *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new Bild();
-    }
+	if (typ == KSGS_BILD)
+		return ((KSGSBildKlasse*)this)->getVal();
+	else
+	{
+		KSGSBildKlasse* tmp = (KSGSBildKlasse*)umwandelnIn(KSGS_BILD);
+		if (tmp)
+		{
+			Bild* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new Bild();
+	}
 }
 
 MausEreignis KSGSKlasseInstanz::getMausEreignis() const
 {
-    if( typ == KSGS_MAUSEREIGNIS )
-        return ( (KSGSMausEreignisKlasse *)this )->getVal();
-    else
-    {
-        KSGSMausEreignisKlasse *tmp = (KSGSMausEreignisKlasse *)umwandelnIn( KSGS_MAUSEREIGNIS );
-        if( tmp )
-        {
-            MausEreignis ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return MausEreignis{ 0, 0, 0, 0, 1, 0, 0 };
-    }
+	if (typ == KSGS_MAUSEREIGNIS)
+		return ((KSGSMausEreignisKlasse*)this)->getVal();
+	else
+	{
+		KSGSMausEreignisKlasse* tmp = (KSGSMausEreignisKlasse*)umwandelnIn(KSGS_MAUSEREIGNIS);
+		if (tmp)
+		{
+			MausEreignis ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return MausEreignis{ 0, 0, 0, 0, 1, 0, 0 };
+	}
 }
 
 TastaturEreignis KSGSKlasseInstanz::getTastaturEreignis() const
 {
-    if( typ == KSGS_TASTATUREREIGNIS )
-        return ( (KSGSTastaturEreignisKlasse *)this )->getVal();
-    else
-    {
-        KSGSTastaturEreignisKlasse *tmp = (KSGSTastaturEreignisKlasse *)umwandelnIn( KSGS_TASTATUREREIGNIS );
-        if( tmp )
-        {
-            TastaturEreignis ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return TastaturEreignis{ 0, 0, 0 };
-    }
+	if (typ == KSGS_TASTATUREREIGNIS)
+		return ((KSGSTastaturEreignisKlasse*)this)->getVal();
+	else
+	{
+		KSGSTastaturEreignisKlasse* tmp = (KSGSTastaturEreignisKlasse*)umwandelnIn(KSGS_TASTATUREREIGNIS);
+		if (tmp)
+		{
+			TastaturEreignis ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return TastaturEreignis{ 0, 0, 0 };
+	}
 }
 
-TextFeld *KSGSKlasseInstanz::getTextFeld() const
+TextFeld* KSGSKlasseInstanz::getTextFeld() const
 {
-    if( typ == KSGS_TEXTFELD )
-        return ( (KSGSTextFeldKlasse *)this )->getVal();
-    else
-    {
-        KSGSTextFeldKlasse *tmp = (KSGSTextFeldKlasse *)umwandelnIn( KSGS_TEXTFELD );
-        if( tmp )
-        {
-            TextFeld *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new TextFeld();
-    }
+	if (typ == KSGS_TEXTFELD)
+		return ((KSGSTextFeldKlasse*)this)->getVal();
+	else
+	{
+		KSGSTextFeldKlasse* tmp = (KSGSTextFeldKlasse*)umwandelnIn(KSGS_TEXTFELD);
+		if (tmp)
+		{
+			TextFeld* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new TextFeld();
+	}
 }
 
-Knopf *KSGSKlasseInstanz::getKnopf() const
+Knopf* KSGSKlasseInstanz::getKnopf() const
 {
-    if( typ == KSGS_KNOPF )
-        return ( (KSGSKnopfKlasse *)this )->getVal();
-    else
-    {
-        KSGSKnopfKlasse *tmp = (KSGSKnopfKlasse *)umwandelnIn( KSGS_KNOPF );
-        if( tmp )
-        {
-            Knopf *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new Knopf();
-    }
+	if (typ == KSGS_KNOPF)
+		return ((KSGSKnopfKlasse*)this)->getVal();
+	else
+	{
+		KSGSKnopfKlasse* tmp = (KSGSKnopfKlasse*)umwandelnIn(KSGS_KNOPF);
+		if (tmp)
+		{
+			Knopf* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new Knopf();
+	}
 }
 
-Fenster *KSGSKlasseInstanz::getFenster() const
+Fenster* KSGSKlasseInstanz::getFenster() const
 {
-    if( typ == KSGS_FENSTER )
-        return ( (KSGSFensterKlasse *)this )->getVal();
-    else
-    {
-        KSGSFensterKlasse *tmp = (KSGSFensterKlasse *)umwandelnIn( KSGS_FENSTER );
-        if( tmp )
-        {
-            Fenster *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new Fenster();
-    }
+	if (typ == KSGS_FENSTER)
+		return ((KSGSFensterKlasse*)this)->getVal();
+	else
+	{
+		KSGSFensterKlasse* tmp = (KSGSFensterKlasse*)umwandelnIn(KSGS_FENSTER);
+		if (tmp)
+		{
+			Fenster* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new Fenster();
+	}
 }
 
-BildZ *KSGSKlasseInstanz::getBildZ() const
+BildZ* KSGSKlasseInstanz::getBildZ() const
 {
-    if( typ == KSGS_BILDO )
-        return ( (KSGSBildZKlasse *)this )->getVal();
-    else
-    {
-        KSGSBildZKlasse *tmp = (KSGSBildZKlasse *)umwandelnIn( KSGS_BILDO );
-        if( tmp )
-        {
-            BildZ *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new BildZ();
-    }
+	if (typ == KSGS_BILDO)
+		return ((KSGSBildZKlasse*)this)->getVal();
+	else
+	{
+		KSGSBildZKlasse* tmp = (KSGSBildZKlasse*)umwandelnIn(KSGS_BILDO);
+		if (tmp)
+		{
+			BildZ* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new BildZ();
+	}
 }
 
-Animation2DData *KSGSKlasseInstanz::getAnimation2DData() const
+Animation2DData* KSGSKlasseInstanz::getAnimation2DData() const
 {
-    if( typ == KSGS_ANIMATION2DDATA )
-        return ( (KSGSAnimation2DDataKlasse *)this )->getVal();
-    else
-    {
-        KSGSAnimation2DDataKlasse *tmp = (KSGSAnimation2DDataKlasse *)umwandelnIn( KSGS_ANIMATION2DDATA );
-        if( tmp )
-        {
-            Animation2DData *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new Animation2DData();
-    }
+	if (typ == KSGS_ANIMATION2DDATA)
+		return ((KSGSAnimation2DDataKlasse*)this)->getVal();
+	else
+	{
+		KSGSAnimation2DDataKlasse* tmp = (KSGSAnimation2DDataKlasse*)umwandelnIn(KSGS_ANIMATION2DDATA);
+		if (tmp)
+		{
+			Animation2DData* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new Animation2DData();
+	}
 }
 
-Animation2D *KSGSKlasseInstanz::getAnimation2D() const
+Animation2D* KSGSKlasseInstanz::getAnimation2D() const
 {
-    if( typ == KSGS_ANIMATION2D )
-        return ( (KSGSAnimation2DKlasse *)this )->getVal();
-    else
-    {
-        KSGSAnimation2DKlasse *tmp = (KSGSAnimation2DKlasse *)umwandelnIn( KSGS_ANIMATION2D );
-        if( tmp )
-        {
-            Animation2D *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new Animation2D();
-    }
+	if (typ == KSGS_ANIMATION2D)
+		return ((KSGSAnimation2DKlasse*)this)->getVal();
+	else
+	{
+		KSGSAnimation2DKlasse* tmp = (KSGSAnimation2DKlasse*)umwandelnIn(KSGS_ANIMATION2D);
+		if (tmp)
+		{
+			Animation2D* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new Animation2D();
+	}
 }
 
-Zeichnung *KSGSKlasseInstanz::getZeichnung() const
+Zeichnung* KSGSKlasseInstanz::getZeichnung() const
 {
-    switch( typ )
-    {
-    case KSGS_TEXTFELD:
-        return ( (KSGSTextFeldKlasse *)this )->zVal();
-    case KSGS_KNOPF:
-        return ( (KSGSKnopfKlasse *)this )->zVal();
-    case KSGS_FENSTER:
-        return ( (KSGSFensterKlasse *)this )->zVal();
-    case KSGS_BILDO:
-        return ( (KSGSBildZKlasse *)this )->zVal();
-    case KSGS_ANIMATION2D:
-        return ( (KSGSAnimation2DKlasse *)this )->zVal();
-    }
-    return 0;
+	switch (typ)
+	{
+	case KSGS_TEXTFELD:
+		return ((KSGSTextFeldKlasse*)this)->zVal();
+	case KSGS_KNOPF:
+		return ((KSGSKnopfKlasse*)this)->zVal();
+	case KSGS_FENSTER:
+		return ((KSGSFensterKlasse*)this)->zVal();
+	case KSGS_BILDO:
+		return ((KSGSBildZKlasse*)this)->zVal();
+	case KSGS_ANIMATION2D:
+		return ((KSGSAnimation2DKlasse*)this)->zVal();
+	}
+	return 0;
 }
 
-RCArray< KSGSVariable > *KSGSKlasseInstanz::getArray() const
+RCArray< KSGSVariable >* KSGSKlasseInstanz::getArray() const
 {
-    if( typ == KSGS_ARRAY )
-        return ( (KSGSArrayKlasse *)this )->getVal();
-    else
-    {
-        KSGSArrayKlasse *tmp = (KSGSArrayKlasse *)umwandelnIn( KSGS_ARRAY );
-        if( tmp )
-        {
-            RCArray< KSGSVariable > *ret = tmp->getVal();
-            tmp->release();
-            return ret;
-        }
-        return new RCArray< KSGSVariable >();
-    }
+	if (typ == KSGS_ARRAY)
+		return ((KSGSArrayKlasse*)this)->getVal();
+	else
+	{
+		KSGSArrayKlasse* tmp = (KSGSArrayKlasse*)umwandelnIn(KSGS_ARRAY);
+		if (tmp)
+		{
+			RCArray< KSGSVariable >* ret = tmp->getVal();
+			tmp->release();
+			return ret;
+		}
+		return new RCArray< KSGSVariable >();
+	}
 }
 
 // static
-KSGSVariable *KSGSKlasseInstanz::erstellVariable( KSGScriptProcessor *zObj, KSGSVariableDef *def )
+KSGSVariable* KSGSKlasseInstanz::erstellVariable(KSGScriptProcessor* zObj, KSGSVariableDef* def)
 {
-    if( !def )
-    {
-        error( 0, {}, zObj );
-        return 0;
-    }
-    if( def->typId < KSGS_TYP_MIN )
-    {
-        error( 0, {}, zObj );
-        return 0;
-    }
-    if( def->typId <= KSGS_TYP_MAX )
-    { // Vordefinierter Typ
-        switch( def->typId )
-        {
-        case KSGS_BOOL:
-            if( def->wert.istGleich( "true" ) )
-                return new KSGSBoolKlasse( zObj, 1 );
-            if( def->wert.istGleich( "false" ) )
-                return new KSGSBoolKlasse( zObj, 0 );
-            if( def->wert.getLength() )
-                return new KSGSBoolKlasse( zObj, (int)def->wert != 0 );
-            return new KSGSBoolKlasse( zObj );
-        case KSGS_INT:
-            if( def->wert.getLength() )
-                return new KSGSIntKlasse( zObj, def->wert );
-            return new KSGSIntKlasse( zObj );
-        case KSGS_DOUBLE:
-            if( def->wert.getLength() )
-                return new KSGSDoubleKlasse( zObj, def->wert );
-            return new KSGSDoubleKlasse( zObj );
-        case KSGS_TEXT:
-            if( def->wert.getLength() )
-                return new KSGSTextKlasse( zObj, def->wert );
-            return new KSGSTextKlasse( zObj );
-        case KSGS_BILD:
-            return new KSGSBildKlasse( zObj );
-        case KSGS_MAUSEREIGNIS:
-            return new KSGSMausEreignisKlasse( zObj );
-        case KSGS_TASTATUREREIGNIS:
-            return new KSGSTastaturEreignisKlasse( zObj );
-        case KSGS_TEXTFELD:
-            return new KSGSTextFeldKlasse( zObj );
-        case KSGS_KNOPF:
-            return new KSGSKnopfKlasse( zObj );
-        case KSGS_FENSTER:
-            return new KSGSFensterKlasse( zObj );
-        case KSGS_BILDO:
-            return new KSGSBildZKlasse( zObj );
-        case KSGS_ANIMATION2DDATA:
-            return new KSGSAnimation2DDataKlasse( zObj );
-        case KSGS_ANIMATION2D:
-            return new KSGSAnimation2DKlasse( zObj );
-        default:
-            error( 1, {}, zObj );
-            break;
-        }
-        return 0;
-    }
-    else if( zObj ) // Im Script Definierter Typ
-        return zObj->erstellKlassenInstanz( def->typId );
-    error( 0, {}, zObj );
-    return 0;
+	if (!def)
+	{
+		error(0, {}, zObj);
+		return 0;
+	}
+	if (def->typId < KSGS_TYP_MIN)
+	{
+		error(0, {}, zObj);
+		return 0;
+	}
+	if (def->typId <= KSGS_TYP_MAX)
+	{ // Vordefinierter Typ
+		switch (def->typId)
+		{
+		case KSGS_BOOL:
+			if (def->wert.istGleich("true"))
+				return new KSGSBoolKlasse(zObj, 1);
+			if (def->wert.istGleich("false"))
+				return new KSGSBoolKlasse(zObj, 0);
+			if (def->wert.getLength())
+				return new KSGSBoolKlasse(zObj, (int)def->wert != 0);
+			return new KSGSBoolKlasse(zObj);
+		case KSGS_INT:
+			if (def->wert.getLength())
+				return new KSGSIntKlasse(zObj, (int)def->wert);
+			return new KSGSIntKlasse(zObj);
+		case KSGS_DOUBLE:
+			if (def->wert.getLength())
+				return new KSGSDoubleKlasse(zObj, (double)def->wert);
+			return new KSGSDoubleKlasse(zObj);
+		case KSGS_TEXT:
+			if (def->wert.getLength())
+				return new KSGSTextKlasse(zObj, def->wert);
+			return new KSGSTextKlasse(zObj);
+		case KSGS_BILD:
+			return new KSGSBildKlasse(zObj);
+		case KSGS_MAUSEREIGNIS:
+			return new KSGSMausEreignisKlasse(zObj);
+		case KSGS_TASTATUREREIGNIS:
+			return new KSGSTastaturEreignisKlasse(zObj);
+		case KSGS_TEXTFELD:
+			return new KSGSTextFeldKlasse(zObj);
+		case KSGS_KNOPF:
+			return new KSGSKnopfKlasse(zObj);
+		case KSGS_FENSTER:
+			return new KSGSFensterKlasse(zObj);
+		case KSGS_BILDO:
+			return new KSGSBildZKlasse(zObj);
+		case KSGS_ANIMATION2DDATA:
+			return new KSGSAnimation2DDataKlasse(zObj);
+		case KSGS_ANIMATION2D:
+			return new KSGSAnimation2DKlasse(zObj);
+		default:
+			error(1, {}, zObj);
+			break;
+		}
+		return 0;
+	}
+	else if (zObj) // Im Script Definierter Typ
+		return zObj->erstellKlassenInstanz(def->typId);
+	error(0, {}, zObj);
+	return 0;
 }
 
 
 // Inhalt der KSGSKlasse Klasse aus KSGSKlasse.h
 // Konstruktor
-KSGSKlasse::KSGSKlasse( int id )
-    : ReferenceCounter()
+KSGSKlasse::KSGSKlasse(int id)
+	: ReferenceCounter()
 {
-    var = new Array< KSGSVariableDef * >();
-    funktionen = new RCArray< KSGSFunktion >();
-    this->id = id;
+	var = new Array< KSGSVariableDef* >();
+	funktionen = new RCArray< KSGSFunktion >();
+	this->id = id;
 }
 
 // Destruktor
 KSGSKlasse::~KSGSKlasse()
 {
-    int anz = var->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-        delete var->get( i );
-    var->release();
-    funktionen->release();
+	int anz = var->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+		delete var->get(i);
+	var->release();
+	funktionen->release();
 }
 
 // nicht constant
-void KSGSKlasse::addVariable( KSGSVariableDef *var )
+void KSGSKlasse::addVariable(KSGSVariableDef* var)
 {
-    this->var->add( var );
+	this->var->add(var);
 }
 
-void KSGSKlasse::addFunktion( KSGSFunktion *func )
+void KSGSKlasse::addFunktion(KSGSFunktion* func)
 {
-    funktionen->add( func );
+	funktionen->add(func);
 }
 
-KSGSKlasseInstanz *KSGSKlasse::erstellInstanz( KSGScriptProcessor *zObj )
+KSGSKlasseInstanz* KSGSKlasse::erstellInstanz(KSGScriptProcessor* zObj)
 {
-    return new KSGSKlasseInstanz( id, var, dynamic_cast<RCArray<KSGSFunktion>*>( funktionen->getThis() ), zObj );
+	return new KSGSKlasseInstanz(id, var, dynamic_cast<RCArray<KSGSFunktion>*>(funktionen->getThis()), zObj);
 }
 
 // constant
 int KSGSKlasse::getId() const
 {
-    return id;
+	return id;
 }

ksgScript/Error/Error.cpp

@@ -3,136 +3,136 @@
 #include <iostream>
 #include <Text.h>
 
-void KSGScript::error( int num, std::initializer_list< const char * > msg, KSGScript::KSGScriptProcessor *zObj )
+void KSGScript::error(int num, std::initializer_list< const char* > msg, KSGScript::KSGScriptProcessor* zObj)
 {
-    Framework::Text logMsg;
-    switch( num )
-    {
-    case 0:
-        logMsg = "Warnung: Fehler beim erstellen einer Variable.";
-        break;
-    case 1:
-        logMsg = "Warnung: Eine Variable dieses Typs kann nicht erstellt werden.";
-        break;
-    case 2:
-        logMsg = "Warnung: Eine Variable mit unbekanntem Typ kann nicht erstellt werden.";
-        break;
-    case 3:
-        logMsg = "Warnung: NULL Zeiger beim ausführen eines Operators.";
-        break;
-    case 4:
-        logMsg = "Error: Die KSGScript Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' konnte nicht geöffnet werden.";
-        break;
-    case 5:
-        logMsg = "Error: Die Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' konnte nicht geladen werden. Unbekanntes Wort in Zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "'";
-        break;
-    case 6:
-        logMsg = "Error: Eine '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' aus der Datei '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' konnte nicht gelesen werden.";
-        break;
-    case 7:
-        logMsg = "Error: Compile Fehler in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' der Datentyp '";
-        logMsg += msg.begin()[ 2 ];
-        logMsg += "' ist bereits definiert.";
-        break;
-    case 8:
-        logMsg = "Error: Compile Fehler in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' die Funktion '";
-        logMsg += msg.begin()[ 2 ];
-        logMsg += "' ist bereits definiert.";
-        break;
-    case 9:
-        logMsg = "Error: Compile Fehler in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' die Variable '";
-        logMsg += msg.begin()[ 2 ];
-        logMsg += "' ist bereits definiert.";
-        break;
-    case 10:
-        logMsg = "Error: Unbekannter Fehler beim Compile Vorgang.";
-        break;
-    case 11:
-        logMsg = "Error: Compile Fehler in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' der Typ '";
-        logMsg += msg.begin()[ 2 ];
-        logMsg += "' der Variable '";
-        logMsg += msg.begin()[ 3 ];
-        logMsg += "' ist nicht definiert.";
-        break;
-    case 12:
-        logMsg = "Error: Compile Fehler in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' der Typ '";
-        logMsg += msg.begin()[ 2 ];
-        logMsg += "' der Funktion '";
-        logMsg += msg.begin()[ 3 ];
-        logMsg += "' ist nicht definiert.";
-        break;
-    case 13:
-        logMsg = "Error: Compile Fehler in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' der Befehl '";
-        logMsg += msg.begin()[ 2 ];
-        logMsg += "' konnte nicht ausgeweret werden.";
-        break;
-    case 14:
-        logMsg = "Warnung: Compile Warnung in Datei '";
-        logMsg += msg.begin()[ 0 ];
-        logMsg += "' zeile '";
-        logMsg += msg.begin()[ 1 ];
-        logMsg += "' die Anzahl der Argumente stimmt nicht mit der Funktion überein.";
-        break;
-    case 15:
-        logMsg = "Warnung: Der rückgabewert stimmt nicht mit dem Funktionstyp überein.";
-        break;
-    case 16:
-        logMsg = "Warnung: Fehler beim konvertieren einer Variable.";
-        break;
-    case 17:
-        logMsg = "Warnung: Zugriffsfehler auf private Variable.";
-        break;
-    case 18:
-        logMsg = "Warnung: Zugriffsfehler auf private Funktion.";
-        break;
-    case 19:
-        logMsg = "Warnung: Funktion konnte nicht gefunden werden.";
-        break;
-    case 20:
-        logMsg = "Warnung: Es wurden nicht alle Parameter für die Funktion angegeben.";
-        break;
-    case 21:
-        logMsg = "Warnung: Der Operator konnte nicht gefunden werden.";
-        break;
-    case 22:
-        logMsg = "Warnung: Ein Befehl konnte nicht richtig ausgeführt werden.";
-        break;
-    }
-    if( zObj )
-        zObj->logNachricht( logMsg );
-    std::cout << "KSGS " << (char *)logMsg << "\n";
+	Framework::Text logMsg;
+	switch (num)
+	{
+	case 0:
+		logMsg = "Warnung: Fehler beim erstellen einer Variable.";
+		break;
+	case 1:
+		logMsg = "Warnung: Eine Variable dieses Typs kann nicht erstellt werden.";
+		break;
+	case 2:
+		logMsg = "Warnung: Eine Variable mit unbekanntem Typ kann nicht erstellt werden.";
+		break;
+	case 3:
+		logMsg = "Warnung: NULL Zeiger beim ausführen eines Operators.";
+		break;
+	case 4:
+		logMsg = "Error: Die KSGScript Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' konnte nicht geöffnet werden.";
+		break;
+	case 5:
+		logMsg = "Error: Die Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' konnte nicht geladen werden. Unbekanntes Wort in Zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "'";
+		break;
+	case 6:
+		logMsg = "Error: Eine '";
+		logMsg += msg.begin()[0];
+		logMsg += "' aus der Datei '";
+		logMsg += msg.begin()[1];
+		logMsg += "' konnte nicht gelesen werden.";
+		break;
+	case 7:
+		logMsg = "Error: Compile Fehler in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' der Datentyp '";
+		logMsg += msg.begin()[2];
+		logMsg += "' ist bereits definiert.";
+		break;
+	case 8:
+		logMsg = "Error: Compile Fehler in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' die Funktion '";
+		logMsg += msg.begin()[2];
+		logMsg += "' ist bereits definiert.";
+		break;
+	case 9:
+		logMsg = "Error: Compile Fehler in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' die Variable '";
+		logMsg += msg.begin()[2];
+		logMsg += "' ist bereits definiert.";
+		break;
+	case 10:
+		logMsg = "Error: Unbekannter Fehler beim Compile Vorgang.";
+		break;
+	case 11:
+		logMsg = "Error: Compile Fehler in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' der Typ '";
+		logMsg += msg.begin()[2];
+		logMsg += "' der Variable '";
+		logMsg += msg.begin()[3];
+		logMsg += "' ist nicht definiert.";
+		break;
+	case 12:
+		logMsg = "Error: Compile Fehler in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' der Typ '";
+		logMsg += msg.begin()[2];
+		logMsg += "' der Funktion '";
+		logMsg += msg.begin()[3];
+		logMsg += "' ist nicht definiert.";
+		break;
+	case 13:
+		logMsg = "Error: Compile Fehler in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' der Befehl '";
+		logMsg += msg.begin()[2];
+		logMsg += "' konnte nicht ausgeweret werden.";
+		break;
+	case 14:
+		logMsg = "Warnung: Compile Warnung in Datei '";
+		logMsg += msg.begin()[0];
+		logMsg += "' zeile '";
+		logMsg += msg.begin()[1];
+		logMsg += "' die Anzahl der Argumente stimmt nicht mit der Funktion überein.";
+		break;
+	case 15:
+		logMsg = "Warnung: Der rückgabewert stimmt nicht mit dem Funktionstyp überein.";
+		break;
+	case 16:
+		logMsg = "Warnung: Fehler beim konvertieren einer Variable.";
+		break;
+	case 17:
+		logMsg = "Warnung: Zugriffsfehler auf private Variable.";
+		break;
+	case 18:
+		logMsg = "Warnung: Zugriffsfehler auf private Funktion.";
+		break;
+	case 19:
+		logMsg = "Warnung: Funktion konnte nicht gefunden werden.";
+		break;
+	case 20:
+		logMsg = "Warnung: Es wurden nicht alle Parameter für die Funktion angegeben.";
+		break;
+	case 21:
+		logMsg = "Warnung: Der Operator konnte nicht gefunden werden.";
+		break;
+	case 22:
+		logMsg = "Warnung: Ein Befehl konnte nicht richtig ausgeführt werden.";
+		break;
+	}
+	if (zObj)
+		zObj->logNachricht(logMsg);
+	std::cout << "KSGS " << (const char*)logMsg << "\n";
 }

ksgScript/Include/KSGScript.h

@@ -9,172 +9,172 @@
 
 namespace Framework
 {
-    class Bild;
-    class TextFeld;
-    class Knopf;
-    class Fenster;
-    class BildZ;
-    class Animation2DData;
-    class Animation2D;
-    class Schrift;
-    class Text;
-    class TextFeld;
-    class TextRenderer;
+	class Bild;
+	class TextFeld;
+	class Knopf;
+	class Fenster;
+	class BildZ;
+	class Animation2DData;
+	class Animation2D;
+	class Schrift;
+	class Text;
+	class TextFeld;
+	class TextRenderer;
 }
 
 namespace KSGScript
 {
-    struct KSGSVariableDef
-    {
-        int typId;
-        int id;
-        int sichtbar; // 0 = global, 1 = global in klasse, 2 = lokal in klasse, 3 = lokal in Funktion
-        Framework::Text wert;
-    };
+	struct KSGSVariableDef
+	{
+		int typId;
+		int id;
+		int sichtbar; // 0 = global, 1 = global in klasse, 2 = lokal in klasse, 3 = lokal in Funktion
+		Framework::Text wert;
+	};
 
-    /*
-    * Vordefinition der KSGS Variable Klasse.
-    * Virtuelle Vordefinition der Klasse KSGSKlasseInstanz aus ../Befehl/KSGSKlasse.h
-    */
+	/*
+	* Vordefinition der KSGS Variable Klasse.
+	* Virtuelle Vordefinition der Klasse KSGSKlasseInstanz aus ../Befehl/KSGSKlasse.h
+	*/
 
-    class KSGSVariable : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // nicht constant
-        virtual KSGSVariable* startFunktion( int id, bool zugriff, Framework::RCArray< KSGSVariable >* parameter ) = 0;
-        virtual KSGSVariable* doOperator( int id, KSGSVariable* rechts ) = 0;
-        virtual void setVariable( int id, KSGSVariable* var ) = 0;
-        // constant
-        virtual KSGSVariable* getVariable( int id, bool zugriff ) const = 0;
-        virtual KSGSVariable* umwandelnIn( int typ ) const = 0;
-        virtual int getTyp() const = 0;
-        // verarbeiten
-        virtual bool getBool() const = 0;
-        virtual int getInt() const = 0;
-        virtual double getDouble() const = 0;
-        virtual Framework::Text* getText() const = 0;
-        virtual Framework::Bild* getBild() const = 0;
-        virtual Framework::MausEreignis getMausEreignis() const = 0;
-        virtual Framework::TastaturEreignis getTastaturEreignis() const = 0;
-        virtual Framework::TextFeld* getTextFeld() const = 0;
-        virtual Framework::Knopf* getKnopf() const = 0;
-        virtual Framework::Fenster* getFenster() const = 0;
-        virtual Framework::BildZ* getBildZ() const = 0;
-        virtual Framework::Animation2DData* getAnimation2DData() const = 0;
-        virtual Framework::Animation2D* getAnimation2D() const = 0;
-        virtual Framework::Zeichnung* getZeichnung() const = 0;
-        virtual Framework::RCArray< KSGSVariable >* getArray() const = 0;
-    };
+	class KSGSVariable : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// nicht constant
+		virtual KSGSVariable* startFunktion(int id, bool zugriff, Framework::RCArray< KSGSVariable >* parameter) = 0;
+		virtual KSGSVariable* doOperator(int id, KSGSVariable* rechts) = 0;
+		virtual void setVariable(int id, KSGSVariable* var) = 0;
+		// constant
+		virtual KSGSVariable* getVariable(int id, bool zugriff) const = 0;
+		virtual KSGSVariable* umwandelnIn(int typ) const = 0;
+		virtual int getTyp() const = 0;
+		// verarbeiten
+		virtual bool getBool() const = 0;
+		virtual int getInt() const = 0;
+		virtual double getDouble() const = 0;
+		virtual Framework::Text* getText() const = 0;
+		virtual Framework::Bild* getBild() const = 0;
+		virtual Framework::MausEreignis getMausEreignis() const = 0;
+		virtual Framework::TastaturEreignis getTastaturEreignis() const = 0;
+		virtual Framework::TextFeld* getTextFeld() const = 0;
+		virtual Framework::Knopf* getKnopf() const = 0;
+		virtual Framework::Fenster* getFenster() const = 0;
+		virtual Framework::BildZ* getBildZ() const = 0;
+		virtual Framework::Animation2DData* getAnimation2DData() const = 0;
+		virtual Framework::Animation2D* getAnimation2D() const = 0;
+		virtual Framework::Zeichnung* getZeichnung() const = 0;
+		virtual Framework::RCArray< KSGSVariable >* getArray() const = 0;
+	};
 
-    class KSGScriptProcessor : public virtual Framework::ReferenceCounter
-    {
-    public:
-        virtual void logNachricht( char* n ) = 0;
-        virtual Framework::Text* convertPfad( char* pf ) = 0;
-        virtual void setVariable( int id, KSGSVariable* var ) = 0;
-        virtual KSGSVariable* startFunktion( int id, Framework::RCArray< KSGSVariable >* parameter ) = 0;
-        virtual KSGSVariable* erstellKlassenInstanz( int id ) = 0;
-        virtual KSGSVariable* getVariable( int id ) const = 0;
-        virtual int getScriptId() const = 0;
-        virtual Framework::Bildschirm* zBildschirm() const = 0;
-        virtual Framework::Schrift* zSchrift() const = 0;
-        virtual int getFunktionId( const char* name ) const = 0;
-        virtual bool istBeendet( int scrId ) const = 0;
-        virtual KSGSVariable* callback( Framework::RCArray< KSGSVariable >* parameter ) const = 0;
-    };
+	class KSGScriptProcessor : public virtual Framework::ReferenceCounter
+	{
+	public:
+		virtual void logNachricht(const char* n) = 0;
+		virtual Framework::Text* convertPfad(const char* pf) = 0;
+		virtual void setVariable(int id, KSGSVariable* var) = 0;
+		virtual KSGSVariable* startFunktion(int id, Framework::RCArray< KSGSVariable >* parameter) = 0;
+		virtual KSGSVariable* erstellKlassenInstanz(int id) = 0;
+		virtual KSGSVariable* getVariable(int id) const = 0;
+		virtual int getScriptId() const = 0;
+		virtual Framework::Bildschirm* zBildschirm() const = 0;
+		virtual Framework::Schrift* zSchrift() const = 0;
+		virtual int getFunktionId(const char* name) const = 0;
+		virtual bool istBeendet(int scrId) const = 0;
+		virtual KSGSVariable* callback(Framework::RCArray< KSGSVariable >* parameter) const = 0;
+	};
 
-    /*
-    * Vordefinierte KSGS Expression Evaluator Klasse
-    */
+	/*
+	* Vordefinierte KSGS Expression Evaluator Klasse
+	*/
 
-    class KSGSExpressionEvaluator : public KSGScriptProcessor
-    {
-    public:
-        virtual KSGSVariable* createParameter( Framework::Text name, int type ) = 0;
-        virtual KSGSVariable* getParameter( Framework::Text name ) = 0;
-        virtual void setExpression( Framework::Text expression ) = 0;
-        virtual KSGSVariable* evaluate() = 0;
-    };
+	class KSGSExpressionEvaluator : public KSGScriptProcessor
+	{
+	public:
+		virtual KSGSVariable* createParameter(Framework::Text name, int type) = 0;
+		virtual KSGSVariable* getParameter(Framework::Text name) = 0;
+		virtual void setExpression(Framework::Text expression) = 0;
+		virtual KSGSVariable* evaluate() = 0;
+	};
 
-    /*
-    * Vordefinition der KSGS Zeichnung Klasse.
-    * Virtuelle Vordefinition der Klasse KSGScriptObj aus ../Main/KSGScriptObj.h
-    */
+	/*
+	* Vordefinition der KSGS Zeichnung Klasse.
+	* Virtuelle Vordefinition der Klasse KSGScriptObj aus ../Main/KSGScriptObj.h
+	*/
 
-    class KSGScriptObj : virtual public Framework::Zeichnung, public KSGScriptProcessor
-    {
-    public:
-        // nicht constant
-        virtual void lock() = 0;
-        virtual void unlock() = 0;
-        virtual void setScriptDatei( const char* pfad ) = 0;
-        virtual void setScriptDatei( Framework::Text* pfad ) = 0;
-        virtual bool neuLaden() = 0;
-        virtual void reset() = 0;
-        virtual void setCallbackParam( void* p ) = 0;
-        virtual void setCallbackFunktion( void(*funktion)(void*, Framework::RCArray< KSGSVariable >*, KSGSVariable**) ) = 0;
-        virtual void setSchriftZ( Framework::Schrift* s ) = 0;
-        virtual void setBildschirmZ( Framework::Bildschirm* s ) = 0;
-        virtual void doPublicMausEreignis( Framework::MausEreignis& me ) = 0;
-        virtual void doTastaturEreignis( Framework::TastaturEreignis& te ) = 0;
-        virtual bool tick( double zeit ) = 0;
-        virtual void render( Framework::Bild& zRObj ) = 0;
-        virtual void setLog( Framework::TextFeld* log ) = 0;
-        // constant
-        virtual Framework::Text* getScriptDateiPfad() const = 0;
-        virtual Framework::Text* zScriptDateiPfad() const = 0;
-        virtual Framework::Schrift* getSchrift() const = 0;
-        virtual Framework::Bildschirm* getBildschirm() const = 0;;
-    };
+	class KSGScriptObj : virtual public Framework::Zeichnung, public KSGScriptProcessor
+	{
+	public:
+		// nicht constant
+		virtual void lock() = 0;
+		virtual void unlock() = 0;
+		virtual void setScriptDatei(const char* pfad) = 0;
+		virtual void setScriptDatei(Framework::Text* pfad) = 0;
+		virtual bool neuLaden() = 0;
+		virtual void reset() = 0;
+		virtual void setCallbackParam(void* p) = 0;
+		virtual void setCallbackFunktion(void(*funktion)(void*, Framework::RCArray< KSGSVariable >*, KSGSVariable**)) = 0;
+		virtual void setSchriftZ(Framework::Schrift* s) = 0;
+		virtual void setBildschirmZ(Framework::Bildschirm* s) = 0;
+		virtual void doPublicMausEreignis(Framework::MausEreignis& me) = 0;
+		virtual void doTastaturEreignis(Framework::TastaturEreignis& te) = 0;
+		virtual bool tick(double zeit) = 0;
+		virtual void render(Framework::Bild& zRObj) = 0;
+		virtual void setLog(Framework::TextFeld* log) = 0;
+		// constant
+		virtual Framework::Text* getScriptDateiPfad() const = 0;
+		virtual Framework::Text* zScriptDateiPfad() const = 0;
+		virtual Framework::Schrift* getSchrift() const = 0;
+		virtual Framework::Bildschirm* getBildschirm() const = 0;;
+	};
 
-    // Ein Textfeld, das eine Entwicklungsumgebung für die KSG-Script Sprache darstellt
-    class KSGScriptEditor : virtual public Framework::ZeichnungHintergrund
-    {
-    public:
-        enum class ColorType
-        {
-            KEYWORD,
-            TYPENAME,
-            PARAMETER_VARIABLE,
-            INSTANCE_VARIABLE,
-            STRING,
-            KOMMENTAR,
-            NORMAL_TEXT,
-            ERROR_UNDERLINE,
-            COLOR_ANZAHL // Dies wird nur benötigt um die Anzahl der verschiedenen Farben zu zählen
-        };
-        // Setzt die zu verwendende Schrift
-        //  s: Die Schrift
-        virtual void setSchriftZ( Framework::Schrift* s ) = 0;
-        // Setzt den zu verwendenden Text Renderer
-        //  t: Der Text Renderer
-        virtual void setTextRendererZ( Framework::TextRenderer* t ) = 0;
-        // Setzt den Text (das Script was verändert werden soll)
-        //  txt: Der Text
-        virtual void setText( Framework::Text* txt ) = 0;
-        // Gibt den aktuellen Text zurück
-        virtual Framework::Text* zText() const = 0;
-        // Schaltet die Fehlererkennung ein oder aus
-        //  on: 1, um die Fehlererkennung einzuschalten, 0 um sie auszuschalten
-        virtual void setErrorDetection( bool on = 1 ) = 0;
-        // Schaltet die Warnungserkennung ein oder aus
-        //  on: 1, um die Warnungserkennung einzuschalten, 0 um sie auszuschalten
-        virtual void setWarningDetection( bool on = 1 ) = 0;
-        // gibt 1 zurück, wenn die Fehlererkennung eingeschaltet ist
-        virtual bool getErrorDetection() const = 0;
-        // gibt 1 zurück, wenn die Warnungserkennung eingeschaltet ist
-        virtual bool getWarningDetection() const = 0;
-        // Setzt die Farbe eines Bestimmten Codetyps
-        //  color: Die Farbe in 0xAARRGGBB Format
-        //  cType: Der Codetyp, der die Farbe bekommen soll
-        virtual void setTextColor( int color, ColorType cType ) = 0;
-    };
-    // DLL Einstieg
-    typedef KSGScriptEditor* (*KSGSGetEditor)();
-    typedef KSGScriptObj* (*KSGSGetZeichnung)();
-    typedef KSGSVariable* (*KSGSGetVariable)(KSGScriptObj* zObj, KSGSVariableDef* def);
-    typedef KSGSExpressionEvaluator* (*KSGSGetExpressionEvaluator)();
-    typedef void (*KSGSSetBild)(KSGSVariable* zBv, Framework::Bild* b);
+	// Ein Textfeld, das eine Entwicklungsumgebung für die KSG-Script Sprache darstellt
+	class KSGScriptEditor : virtual public Framework::ZeichnungHintergrund
+	{
+	public:
+		enum class ColorType
+		{
+			KEYWORD,
+			TYPENAME,
+			PARAMETER_VARIABLE,
+			INSTANCE_VARIABLE,
+			STRING,
+			KOMMENTAR,
+			NORMAL_TEXT,
+			ERROR_UNDERLINE,
+			COLOR_ANZAHL // Dies wird nur benötigt um die Anzahl der verschiedenen Farben zu zählen
+		};
+		// Setzt die zu verwendende Schrift
+		//  s: Die Schrift
+		virtual void setSchriftZ(Framework::Schrift* s) = 0;
+		// Setzt den zu verwendenden Text Renderer
+		//  t: Der Text Renderer
+		virtual void setTextRendererZ(Framework::TextRenderer* t) = 0;
+		// Setzt den Text (das Script was verändert werden soll)
+		//  txt: Der Text
+		virtual void setText(Framework::Text* txt) = 0;
+		// Gibt den aktuellen Text zurück
+		virtual Framework::Text* zText() const = 0;
+		// Schaltet die Fehlererkennung ein oder aus
+		//  on: 1, um die Fehlererkennung einzuschalten, 0 um sie auszuschalten
+		virtual void setErrorDetection(bool on = 1) = 0;
+		// Schaltet die Warnungserkennung ein oder aus
+		//  on: 1, um die Warnungserkennung einzuschalten, 0 um sie auszuschalten
+		virtual void setWarningDetection(bool on = 1) = 0;
+		// gibt 1 zurück, wenn die Fehlererkennung eingeschaltet ist
+		virtual bool getErrorDetection() const = 0;
+		// gibt 1 zurück, wenn die Warnungserkennung eingeschaltet ist
+		virtual bool getWarningDetection() const = 0;
+		// Setzt die Farbe eines Bestimmten Codetyps
+		//  color: Die Farbe in 0xAARRGGBB Format
+		//  cType: Der Codetyp, der die Farbe bekommen soll
+		virtual void setTextColor(int color, ColorType cType) = 0;
+	};
+	// DLL Einstieg
+	typedef KSGScriptEditor* (*KSGSGetEditor)();
+	typedef KSGScriptObj* (*KSGSGetZeichnung)();
+	typedef KSGSVariable* (*KSGSGetVariable)(KSGScriptObj* zObj, KSGSVariableDef* def);
+	typedef KSGSExpressionEvaluator* (*KSGSGetExpressionEvaluator)();
+	typedef void (*KSGSSetBild)(KSGSVariable* zBv, Framework::Bild* b);
 }
 #define KSGS_START_FUNKTION "GetNewKSGScriptObj"
 #define KSGS_EDITOR_FUNKTION "GetNewKSGEditorObj"

ksgScript/Klassen/KSGSText.cpp

@@ -9,212 +9,212 @@ using namespace KSGScript;
 
 // Inhalt der KSGSTextKlasse Klasse aus KSGSText.h
 // Konstruktor
-KSGSTextKlasse::KSGSTextKlasse( KSGScriptProcessor *zObj, const char *std )
-    : KSGSKlasseInstanz( KSGS_TEXT, 0, 0, zObj )
+KSGSTextKlasse::KSGSTextKlasse(KSGScriptProcessor* zObj, const char* std)
+	: KSGSKlasseInstanz(KSGS_TEXT, 0, 0, zObj)
 {
-    val = new Text( std );
+	val = new Text(std);
 }
 
 // Destruktor
 KSGSTextKlasse::~KSGSTextKlasse()
 {
-    val->release();
+	val->release();
 }
 
 // nicht constant
-KSGSVariable *KSGSTextKlasse::startFunktion( int id, bool access, RCArray< KSGSVariable > *parameter )
+KSGSVariable* KSGSTextKlasse::startFunktion(int id, bool access, RCArray< KSGSVariable >* parameter)
 {
-    KSGSVariable *ret = 0;
-    switch( id )
-    {
-    case 0: // void setSuchGrenzen( int, int )
-        if( parameter->getEintragAnzahl() < 2 )
-            error( 20, {}, obj );
-        val->setSuchGrenzen( (char)( parameter->z( 0 ) ? parameter->z( 0 )->getInt() : 0 ),
-                             (char)( parameter->z( 1 ) ? parameter->z( 1 )->getInt() : 0 ) );
-        break;
-    case 1: // void setText( Text )
-        if( parameter->getEintragAnzahl() < 1 )
-            error( 20, {}, obj );
-        val->setText( parameter->z( 0 ) ? parameter->z( 0 )->getText() : new Text( "" ) );
-        break;
-    case 2: // void anhängen( Text )
-        if( parameter->getEintragAnzahl() < 1 )
-            error( 20, {}, obj );
-        val->append( parameter->z( 0 ) ? parameter->z( 0 )->getText() : new Text( "" ) );
-        break;
-    case 3: // void einfügen( int, Text )
-        if( parameter->getEintragAnzahl() < 2 )
-            error( 20, {}, obj );
-        val->insert( parameter->z( 0 ) ? parameter->z( 0 )->getInt() : 0,
-                     parameter->z( 1 ) ? parameter->z( 1 )->getText() : new Text( "" ) );
-        break;
-    case 4: // void ersetzen( int, int, Text )
-        if( parameter->getEintragAnzahl() < 3 )
-            error( 20, {}, obj );
-        val->ersetzen( parameter->z( 0 ) ? parameter->z( 0 )->getInt() : 0,
-                       parameter->z( 1 ) ? parameter->z( 1 )->getInt() : 0,
-                       parameter->z( 2 ) ? parameter->z( 2 )->getText() : new Text( "" ) );
-        break;
-    case 5: // void löschen( int, int )
-        if( parameter->getEintragAnzahl() < 2 )
-            error( 20, {}, obj );
-        val->remove( parameter->z( 0 ) ? parameter->z( 0 )->getInt() : 0,
-                     parameter->z( 1 ) ? parameter->z( 1 )->getInt() : 0 );
-        break;
-    case 6: // int getLänge()
-        ret = new KSGSIntKlasse( obj, val->getLength() );
-        break;
-    case 7: // bool hat( Text )
-        if( parameter->getEintragAnzahl() < 1 )
-            error( 20, {}, obj );
-        ret = new KSGSBoolKlasse( obj, val->hat( parameter->z( 0 ) ? parameter->z( 0 )->getText() : new Text( "" ) ) );
-        break;
-    case 8: // bool istGleich( Text )
-        if( parameter->getEintragAnzahl() < 1 )
-            error( 20, {}, obj );
-        ret = new KSGSBoolKlasse( obj, val->istGleich( parameter->z( 0 ) ? parameter->z( 0 )->getText() : new Text( "" ) ) );
-        break;
-    case 9: // int anzahlVon( Text )
-        if( parameter->getEintragAnzahl() < 1 )
-            error( 20, {}, obj );
-        ret = new KSGSIntKlasse( obj, val->anzahlVon( parameter->z( 0 ) ? parameter->z( 0 )->getText() : new Text( "" ) ) );
-        break;
-    case 10: // int positionVon( Text, int )
-        if( parameter->getEintragAnzahl() < 2 )
-            error( 20, {}, obj );
-        ret = new KSGSIntKlasse( obj, val->positionVon( parameter->z( 0 ) ? parameter->z( 0 )->getText() : new Text( "" ),
-                                                        parameter->z( 1 ) ? parameter->z( 1 )->getInt() : 0 ) );
-        break;
-    case 11: // Text getTeilText( int, int )
-        if( 1 )
-        {
-            Text *txt = val->getTeilText( parameter->z( 0 ) ? parameter->z( 0 )->getInt() : 0,
-                                          parameter->z( 1 ) ? parameter->z( 1 )->getInt() : 0 );
-            if( !txt )
-                txt = new Text();
-            ret = new KSGSTextKlasse( obj, *txt );
-            txt->release();
-        }
-        break;
-    default: // unbekannt
-        error( 19, {}, obj );
-        break;
-    }
-    parameter->release();
-    return ret;
+	KSGSVariable* ret = 0;
+	switch (id)
+	{
+	case 0: // void setSuchGrenzen( int, int )
+		if (parameter->getEintragAnzahl() < 2)
+			error(20, {}, obj);
+		val->setSuchGrenzen((char)(parameter->z(0) ? parameter->z(0)->getInt() : 0),
+			(char)(parameter->z(1) ? parameter->z(1)->getInt() : 0));
+		break;
+	case 1: // void setText( Text )
+		if (parameter->getEintragAnzahl() < 1)
+			error(20, {}, obj);
+		val->setText(parameter->z(0) ? parameter->z(0)->getText() : new Text(""));
+		break;
+	case 2: // void anhängen( Text )
+		if (parameter->getEintragAnzahl() < 1)
+			error(20, {}, obj);
+		val->append(parameter->z(0) ? parameter->z(0)->getText() : new Text(""));
+		break;
+	case 3: // void einfügen( int, Text )
+		if (parameter->getEintragAnzahl() < 2)
+			error(20, {}, obj);
+		val->insert(parameter->z(0) ? parameter->z(0)->getInt() : 0,
+			parameter->z(1) ? parameter->z(1)->getText() : new Text(""));
+		break;
+	case 4: // void ersetzen( int, int, Text )
+		if (parameter->getEintragAnzahl() < 3)
+			error(20, {}, obj);
+		val->ersetzen(parameter->z(0) ? parameter->z(0)->getInt() : 0,
+			parameter->z(1) ? parameter->z(1)->getInt() : 0,
+			parameter->z(2) ? parameter->z(2)->getText() : new Text(""));
+		break;
+	case 5: // void löschen( int, int )
+		if (parameter->getEintragAnzahl() < 2)
+			error(20, {}, obj);
+		val->remove(parameter->z(0) ? parameter->z(0)->getInt() : 0,
+			parameter->z(1) ? parameter->z(1)->getInt() : 0);
+		break;
+	case 6: // int getLänge()
+		ret = new KSGSIntKlasse(obj, val->getLength());
+		break;
+	case 7: // bool hat( Text )
+		if (parameter->getEintragAnzahl() < 1)
+			error(20, {}, obj);
+		ret = new KSGSBoolKlasse(obj, val->hat(parameter->z(0) ? parameter->z(0)->getText() : new Text("")));
+		break;
+	case 8: // bool istGleich( Text )
+		if (parameter->getEintragAnzahl() < 1)
+			error(20, {}, obj);
+		ret = new KSGSBoolKlasse(obj, val->istGleich(parameter->z(0) ? parameter->z(0)->getText() : new Text("")));
+		break;
+	case 9: // int anzahlVon( Text )
+		if (parameter->getEintragAnzahl() < 1)
+			error(20, {}, obj);
+		ret = new KSGSIntKlasse(obj, val->anzahlVon(parameter->z(0) ? parameter->z(0)->getText() : new Text("")));
+		break;
+	case 10: // int positionVon( Text, int )
+		if (parameter->getEintragAnzahl() < 2)
+			error(20, {}, obj);
+		ret = new KSGSIntKlasse(obj, val->positionVon(parameter->z(0) ? parameter->z(0)->getText() : new Text(""),
+			parameter->z(1) ? parameter->z(1)->getInt() : 0));
+		break;
+	case 11: // Text getTeilText( int, int )
+		if (1)
+		{
+			Text* txt = val->getTeilText(parameter->z(0) ? parameter->z(0)->getInt() : 0,
+				parameter->z(1) ? parameter->z(1)->getInt() : 0);
+			if (!txt)
+				txt = new Text();
+			ret = new KSGSTextKlasse(obj, *txt);
+			txt->release();
+		}
+		break;
+	default: // unbekannt
+		error(19, {}, obj);
+		break;
+	}
+	parameter->release();
+	return ret;
 }
 
-KSGSVariable *KSGSTextKlasse::doOperator( int id, KSGSVariable *rechts )
+KSGSVariable* KSGSTextKlasse::doOperator(int id, KSGSVariable* rechts)
 {
-    if( !rechts )
-    {
-        error( 3, {}, obj );
-        return 0;
-    }
-    KSGSVariable *ret = 0;
-    switch( id )
-    {
-    case KSGS_O_SET:
-        val->setText( rechts->getText() );
-        ret = dynamic_cast<KSGSVariable *>( getThis() );
-        break;
-    case KSGS_O_PLUSSET:
-        val->append( rechts->getText() );
-        ret = dynamic_cast<KSGSVariable *>( getThis() );
-        break;
-    case KSGS_O_MINUSSET:
-        val->append( rechts->getText() );
-        ret = dynamic_cast<KSGSVariable *>( getThis() );
-        break;
-    case KSGS_O_GLEICH:
-        ret = new KSGSBoolKlasse( obj, val->istGleich( rechts->getText() ) );
-        break;
-    case KSGS_O_KLEINERGLEICH:
-        if( 1 )
-        {
-            Text *txt = rechts->getText();
-            ret = new KSGSBoolKlasse( obj, val->istGleich( rechts->getText() ) || *val < *txt );
-            txt->release();
-        }
-        break;
-    case KSGS_O_GREATERGLEICH:
-        if( 1 )
-        {
-            Text *txt = rechts->getText();
-            ret = new KSGSBoolKlasse( obj, val->istGleich( rechts->getText() ) || *val > *txt );
-            txt->release();
-        }
-        break;
-    case KSGS_O_UNGLEICH:
-        ret = new KSGSBoolKlasse( obj, !val->istGleich( rechts->getText() ) );
-        break;
-    case KSGS_O_KLEINER:
-        if( 1 )
-        {
-            Text *txt = rechts->getText();
-            ret = new KSGSBoolKlasse( obj, *val < *txt );
-            txt->release();
-        }
-        break;
-    case KSGS_O_GREATER:
-        if( 1 )
-        {
-            Text *txt = rechts->getText();
-            ret = new KSGSBoolKlasse( obj, *val > *txt );
-            txt->release();
-        }
-        break;
-    case KSGS_O_PLUS:
-        if( 1 )
-        {
-            Text *txt = rechts->getText();
-            ret = new KSGSTextKlasse( obj, Text( (char *)val ) += (char *)*txt );
-            txt->release();
-        }
-        break;
-    case KSGS_O_MINUS:
-        if( 1 )
-        {
-            Text t( (char *)val );
-            t.remove( rechts->getText() );
-            ret = new KSGSTextKlasse( obj, t );
-        }
-        break;
-    }
-    if( !ret )
-        error( 21, {}, obj );
-    if( rechts )
-        rechts->release();
-    return ret;
+	if (!rechts)
+	{
+		error(3, {}, obj);
+		return 0;
+	}
+	KSGSVariable* ret = 0;
+	switch (id)
+	{
+	case KSGS_O_SET:
+		val->setText(rechts->getText());
+		ret = dynamic_cast<KSGSVariable*>(getThis());
+		break;
+	case KSGS_O_PLUSSET:
+		val->append(rechts->getText());
+		ret = dynamic_cast<KSGSVariable*>(getThis());
+		break;
+	case KSGS_O_MINUSSET:
+		val->append(rechts->getText());
+		ret = dynamic_cast<KSGSVariable*>(getThis());
+		break;
+	case KSGS_O_GLEICH:
+		ret = new KSGSBoolKlasse(obj, val->istGleich(rechts->getText()));
+		break;
+	case KSGS_O_KLEINERGLEICH:
+		if (1)
+		{
+			Text* txt = rechts->getText();
+			ret = new KSGSBoolKlasse(obj, val->istGleich(rechts->getText()) || *val < *txt);
+			txt->release();
+		}
+		break;
+	case KSGS_O_GREATERGLEICH:
+		if (1)
+		{
+			Text* txt = rechts->getText();
+			ret = new KSGSBoolKlasse(obj, val->istGleich(rechts->getText()) || *val > *txt);
+			txt->release();
+		}
+		break;
+	case KSGS_O_UNGLEICH:
+		ret = new KSGSBoolKlasse(obj, !val->istGleich(rechts->getText()));
+		break;
+	case KSGS_O_KLEINER:
+		if (1)
+		{
+			Text* txt = rechts->getText();
+			ret = new KSGSBoolKlasse(obj, *val < *txt);
+			txt->release();
+		}
+		break;
+	case KSGS_O_GREATER:
+		if (1)
+		{
+			Text* txt = rechts->getText();
+			ret = new KSGSBoolKlasse(obj, *val > *txt);
+			txt->release();
+		}
+		break;
+	case KSGS_O_PLUS:
+		if (1)
+		{
+			Text* txt = rechts->getText();
+			ret = new KSGSTextKlasse(obj, Text(*val) += *txt);
+			txt->release();
+		}
+		break;
+	case KSGS_O_MINUS:
+		if (1)
+		{
+			Text t((char*)val);
+			t.remove(rechts->getText());
+			ret = new KSGSTextKlasse(obj, t);
+		}
+		break;
+	}
+	if (!ret)
+		error(21, {}, obj);
+	if (rechts)
+		rechts->release();
+	return ret;
 }
 
 // constant
-Text *KSGSTextKlasse::getVal() const
+Text* KSGSTextKlasse::getVal() const
 {
-    return dynamic_cast<Text *>( val->getThis() );
+	return dynamic_cast<Text*>(val->getThis());
 }
 
-Text *KSGSTextKlasse::zVal() const
+Text* KSGSTextKlasse::zVal() const
 {
-    return val;
+	return val;
 }
 
-KSGSVariable *KSGSTextKlasse::umwandelnIn( int typ ) const
+KSGSVariable* KSGSTextKlasse::umwandelnIn(int typ) const
 {
-    switch( typ )
-    {
-    case KSGS_BOOL:
-        if( val->istGleich( "true" ) )
-            return new KSGSBoolKlasse( obj, 1 );
-        if( val->istGleich( "false" ) )
-            return new KSGSBoolKlasse( obj, 0 );
-        return new KSGSBoolKlasse( obj, (int)*val != 0 );
-    case KSGS_INT:
-        return new KSGSIntKlasse( obj, *val );
-    case KSGS_DOUBLE:
-        return new KSGSDoubleKlasse( obj, *val );
-    }
-    error( 16, {}, obj );
-    return 0;
+	switch (typ)
+	{
+	case KSGS_BOOL:
+		if (val->istGleich("true"))
+			return new KSGSBoolKlasse(obj, 1);
+		if (val->istGleich("false"))
+			return new KSGSBoolKlasse(obj, 0);
+		return new KSGSBoolKlasse(obj, (int)*val != 0);
+	case KSGS_INT:
+		return new KSGSIntKlasse(obj, (int)*val);
+	case KSGS_DOUBLE:
+		return new KSGSDoubleKlasse(obj, (double)*val);
+	}
+	error(16, {}, obj);
+	return 0;
 }

ksgScript/Leser/KSGSLeser.cpp

@@ -9,1555 +9,1555 @@
 
 using namespace KSGScript;
 
-void KSGScript::removeLehr( Text *txt )
+void KSGScript::removeLehr(Text* txt)
 {
-    if( !txt->getLength() )
-        return;
-    while( txt->getLength() && ( *txt[ 0 ] == ' ' || *txt[ 0 ] == '\n' || *txt[ 0 ] == '\r' || *txt[ 0 ] == '\t' ) )
-        txt->remove( 0 );
-    while( txt->getLength() && ( txt->getText()[ txt->getLength() - 1 ] == ' ' || txt->getText()[ txt->getLength() - 1 ] == '\n' ||
-                                 txt->getText()[ txt->getLength() - 1 ] == '\r' || txt->getText()[ txt->getLength() - 1 ] == '\t' ) )
-        txt->remove( txt->getLength() - 1 );
+	if (!txt->getLength())
+		return;
+	while (txt->getLength() && (*txt[0] == ' ' || *txt[0] == '\n' || *txt[0] == '\r' || *txt[0] == '\t'))
+		txt->remove(0);
+	while (txt->getLength() && (txt->getText()[txt->getLength() - 1] == ' ' || txt->getText()[txt->getLength() - 1] == '\n' ||
+		txt->getText()[txt->getLength() - 1] == '\r' || txt->getText()[txt->getLength() - 1] == '\t'))
+		txt->remove(txt->getLength() - 1);
 }
 
-void KSGScript::removeKlammer( Text *txt )
+void KSGScript::removeKlammer(Text* txt)
 {
-    if( !txt->getLength() )
-        return;
-    removeLehr( txt );
-    while( *txt[ 0 ] == '(' && txt->getText()[ txt->getLength() - 1 ] == ')' )
-    {
-        int count = 0;
-        for( int i = 0; i < txt->getLength(); i++ )
-        {
-            if( txt->getText()[ i ] == '(' )
-                count++;
-            if( txt->getText()[ i ] == ')' )
-                count--;
-            if( !count && i != txt->getLength() - 1 )
-                return;
-        }
-        txt->remove( 0 );
-        txt->remove( txt->getLength() - 1 );
-        removeLehr( txt );
-        if( !txt->getLength() )
-            return;
-    }
+	if (!txt->getLength())
+		return;
+	removeLehr(txt);
+	while (*txt[0] == '(' && txt->getText()[txt->getLength() - 1] == ')')
+	{
+		int count = 0;
+		for (int i = 0; i < txt->getLength(); i++)
+		{
+			if (txt->getText()[i] == '(')
+				count++;
+			if (txt->getText()[i] == ')')
+				count--;
+			if (!count && i != txt->getLength() - 1)
+				return;
+		}
+		txt->remove(0);
+		txt->remove(txt->getLength() - 1);
+		removeLehr(txt);
+		if (!txt->getLength())
+			return;
+	}
 }
 
-int KSGScript::hatOperator( Text *txt )
+int KSGScript::hatOperator(Text* txt)
 {
-    if( txt->hat( "+=" ) )
-        return KSGS_O_PLUSSET;
-    if( txt->hat( "-=" ) )
-        return KSGS_O_MINUSSET;
-    if( txt->hat( "*=" ) )
-        return KSGS_O_MAHLSET;
-    if( txt->hat( "/=" ) )
-        return KSGS_O_GETEILTSET;
-    if( txt->hat( "&=" ) )
-        return KSGS_O_UNDSET;
-    if( txt->hat( "|=" ) )
-        return KSGS_O_ODERSET;
-    if( txt->hat( "==" ) )
-        return KSGS_O_GLEICH;
-    if( txt->hat( "<=" ) )
-        return KSGS_O_KLEINERGLEICH;
-    if( txt->hat( ">=" ) )
-        return KSGS_O_GREATERGLEICH;
-    if( txt->hat( "!=" ) )
-        return KSGS_O_UNGLEICH;
-    if( txt->hat( "||" ) )
-        return KSGS_O_ODER;
-    if( txt->hat( "&&" ) )
-        return KSGS_O_UND;
-    if( txt->hat( "++" ) )
-        return KSGS_O_PLUS1;
-    if( txt->hat( "--" ) )
-        return KSGS_O_MINUS1;
-    if( txt->hat( "<<" ) )
-        return KSGS_O_NACHLINKS;
-    if( txt->hat( ">>" ) )
-        return KSGS_O_NACHRECHTS;
-    if( txt->hat( "=" ) )
-        return KSGS_O_SET;
-    if( txt->hat( "<" ) )
-        return KSGS_O_KLEINER;
-    if( txt->hat( ">" ) )
-        return KSGS_O_GREATER;
-    if( txt->hat( "|" ) )
-        return KSGS_O_BITODER;
-    if( txt->hat( "&" ) )
-        return KSGS_O_BITUND;
-    if( txt->hat( "+" ) )
-        return KSGS_O_PLUS;
-    if( txt->hat( "-" ) )
-        return KSGS_O_MINUS;
-    if( txt->hat( "*" ) )
-        return KSGS_O_MAHL;
-    if( txt->hat( "/" ) )
-        return KSGS_O_GETEILT;
-    if( txt->hat( "%" ) )
-        return KSGS_O_REST;
-    if( txt->hat( "!" ) )
-        return KSGS_O_NICHT;
-    if( txt->hat( "~" ) )
-        return KSGS_O_BITNICHT;
-    return -1;
+	if (txt->hat("+="))
+		return KSGS_O_PLUSSET;
+	if (txt->hat("-="))
+		return KSGS_O_MINUSSET;
+	if (txt->hat("*="))
+		return KSGS_O_MAHLSET;
+	if (txt->hat("/="))
+		return KSGS_O_GETEILTSET;
+	if (txt->hat("&="))
+		return KSGS_O_UNDSET;
+	if (txt->hat("|="))
+		return KSGS_O_ODERSET;
+	if (txt->hat("=="))
+		return KSGS_O_GLEICH;
+	if (txt->hat("<="))
+		return KSGS_O_KLEINERGLEICH;
+	if (txt->hat(">="))
+		return KSGS_O_GREATERGLEICH;
+	if (txt->hat("!="))
+		return KSGS_O_UNGLEICH;
+	if (txt->hat("||"))
+		return KSGS_O_ODER;
+	if (txt->hat("&&"))
+		return KSGS_O_UND;
+	if (txt->hat("++"))
+		return KSGS_O_PLUS1;
+	if (txt->hat("--"))
+		return KSGS_O_MINUS1;
+	if (txt->hat("<<"))
+		return KSGS_O_NACHLINKS;
+	if (txt->hat(">>"))
+		return KSGS_O_NACHRECHTS;
+	if (txt->hat("="))
+		return KSGS_O_SET;
+	if (txt->hat("<"))
+		return KSGS_O_KLEINER;
+	if (txt->hat(">"))
+		return KSGS_O_GREATER;
+	if (txt->hat("|"))
+		return KSGS_O_BITODER;
+	if (txt->hat("&"))
+		return KSGS_O_BITUND;
+	if (txt->hat("+"))
+		return KSGS_O_PLUS;
+	if (txt->hat("-"))
+		return KSGS_O_MINUS;
+	if (txt->hat("*"))
+		return KSGS_O_MAHL;
+	if (txt->hat("/"))
+		return KSGS_O_GETEILT;
+	if (txt->hat("%"))
+		return KSGS_O_REST;
+	if (txt->hat("!"))
+		return KSGS_O_NICHT;
+	if (txt->hat("~"))
+		return KSGS_O_BITNICHT;
+	return -1;
 }
 
-int KSGScript::getOperatorPos( Text *txt, int *len )
+int KSGScript::getOperatorPos(Text* txt, int* len)
 {
-    *len = 2;
-    if( txt->hat( "+=" ) )
-        return txt->positionVon( "+=" );
-    if( txt->hat( "-=" ) )
-        return txt->positionVon( "-=" );
-    if( txt->hat( "*=" ) )
-        return txt->positionVon( "*=" );
-    if( txt->hat( "/=" ) )
-        return txt->positionVon( "/=" );
-    if( txt->hat( "&=" ) )
-        return txt->positionVon( "&=" );
-    if( txt->hat( "|=" ) )
-        return txt->positionVon( "|=" );
-    if( txt->hat( "==" ) )
-        return txt->positionVon( "==" );
-    if( txt->hat( "<=" ) )
-        return txt->positionVon( "<=" );
-    if( txt->hat( ">=" ) )
-        return txt->positionVon( ">=" );
-    if( txt->hat( "!=" ) )
-        return txt->positionVon( "!=" );
-    if( txt->hat( "||" ) )
-        return txt->positionVon( "||" );
-    if( txt->hat( "&&" ) )
-        return txt->positionVon( "&&" );
-    if( txt->hat( "++" ) )
-        return txt->positionVon( "++" );
-    if( txt->hat( "--" ) )
-        return txt->positionVon( "--" );
-    if( txt->hat( "<<" ) )
-        return txt->positionVon( "<<" );
-    if( txt->hat( ">>" ) )
-        return txt->positionVon( ">>" );
-    *len = 1;
-    if( txt->hat( "=" ) )
-        return txt->positionVon( "=" );
-    if( txt->hat( "<" ) )
-        return txt->positionVon( "<" );
-    if( txt->hat( ">" ) )
-        return txt->positionVon( ">" );
-    if( txt->hat( "|" ) )
-        return txt->positionVon( "|" );
-    if( txt->hat( "&" ) )
-        return txt->positionVon( "&" );
-    if( txt->hat( "+" ) )
-        return txt->positionVon( "+" );
-    if( txt->hat( "-" ) )
-        return txt->positionVon( "-" );
-    if( txt->hat( "*" ) )
-        return txt->positionVon( "*" );
-    if( txt->hat( "/" ) )
-        return txt->positionVon( "/" );
-    if( txt->hat( "%" ) )
-        return txt->positionVon( "%" );
-    if( txt->hat( "!" ) )
-        return txt->positionVon( "!" );
-    if( txt->hat( "~" ) )
-        return txt->positionVon( "~" );
-    *len = 0;
-    return -1;
+	*len = 2;
+	if (txt->hat("+="))
+		return txt->positionVon("+=");
+	if (txt->hat("-="))
+		return txt->positionVon("-=");
+	if (txt->hat("*="))
+		return txt->positionVon("*=");
+	if (txt->hat("/="))
+		return txt->positionVon("/=");
+	if (txt->hat("&="))
+		return txt->positionVon("&=");
+	if (txt->hat("|="))
+		return txt->positionVon("|=");
+	if (txt->hat("=="))
+		return txt->positionVon("==");
+	if (txt->hat("<="))
+		return txt->positionVon("<=");
+	if (txt->hat(">="))
+		return txt->positionVon(">=");
+	if (txt->hat("!="))
+		return txt->positionVon("!=");
+	if (txt->hat("||"))
+		return txt->positionVon("||");
+	if (txt->hat("&&"))
+		return txt->positionVon("&&");
+	if (txt->hat("++"))
+		return txt->positionVon("++");
+	if (txt->hat("--"))
+		return txt->positionVon("--");
+	if (txt->hat("<<"))
+		return txt->positionVon("<<");
+	if (txt->hat(">>"))
+		return txt->positionVon(">>");
+	*len = 1;
+	if (txt->hat("="))
+		return txt->positionVon("=");
+	if (txt->hat("<"))
+		return txt->positionVon("<");
+	if (txt->hat(">"))
+		return txt->positionVon(">");
+	if (txt->hat("|"))
+		return txt->positionVon("|");
+	if (txt->hat("&"))
+		return txt->positionVon("&");
+	if (txt->hat("+"))
+		return txt->positionVon("+");
+	if (txt->hat("-"))
+		return txt->positionVon("-");
+	if (txt->hat("*"))
+		return txt->positionVon("*");
+	if (txt->hat("/"))
+		return txt->positionVon("/");
+	if (txt->hat("%"))
+		return txt->positionVon("%");
+	if (txt->hat("!"))
+		return txt->positionVon("!");
+	if (txt->hat("~"))
+		return txt->positionVon("~");
+	*len = 0;
+	return -1;
 }
 
 // Lese Strukturen
 KSGSLeseBefehl::~KSGSLeseBefehl()
 {
-    int anz = listA.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-        delete listA.get( i );
-    anz = listB.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-        delete listB.get( i );
+	int anz = listA.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+		delete listA.get(i);
+	anz = listB.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+		delete listB.get(i);
 }
 
 void KSGSLeseFunktion::release()
 {
-    if( !--ref )
-        delete this;
+	if (!--ref)
+		delete this;
 }
 
 KSGSLeseFunktion::~KSGSLeseFunktion()
 {
-    int anz3 = parameter.getEintragAnzahl();
-    for( int k = 0; k < anz3; k++ )
-        delete parameter.get( k );
-    anz3 = befehle.getEintragAnzahl();
-    for( int k = 0; k < anz3; k++ )
-        delete befehle.get( k );
+	int anz3 = parameter.getEintragAnzahl();
+	for (int k = 0; k < anz3; k++)
+		delete parameter.get(k);
+	anz3 = befehle.getEintragAnzahl();
+	for (int k = 0; k < anz3; k++)
+		delete befehle.get(k);
 }
 
 void KSGSLeseKlasse::release()
 {
-    if( !--ref )
-        delete this;
+	if (!--ref)
+		delete this;
 }
 
 KSGSLeseKlasse::~KSGSLeseKlasse()
 {
-    int anz2 = variablen.getEintragAnzahl();
-    for( int j = 0; j < anz2; j++ )
-        delete variablen.get( j );
-    anz2 = funktionen.getEintragAnzahl();
-    for( int j = 0; j < anz2; j++ )
-        funktionen.get( j )->release();
+	int anz2 = variablen.getEintragAnzahl();
+	for (int j = 0; j < anz2; j++)
+		delete variablen.get(j);
+	anz2 = funktionen.getEintragAnzahl();
+	for (int j = 0; j < anz2; j++)
+		funktionen.get(j)->release();
 }
 
 KSGSLeseScript::~KSGSLeseScript()
 {
-    int anz = variablen.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-        delete variablen.get( i );
-    anz = funktionen.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-        funktionen.get( i )->release();
-    anz = klassen.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-        klassen.get( i )->release();
+	int anz = variablen.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+		delete variablen.get(i);
+	anz = funktionen.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+		funktionen.get(i)->release();
+	anz = klassen.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+		klassen.get(i)->release();
 }
 
 
 // Inhalt der KSGSLeser klasse aus KSGSLeser.h
 // Konstruktor
-KSGSLeser::KSGSLeser( Reader *reader, KSGScriptProcessor *zObj, Text fileName )
-    : KSGSLeser()
+KSGSLeser::KSGSLeser(Reader* reader, KSGScriptProcessor* zObj, Text fileName)
+	: KSGSLeser()
 {
-    this->zObj = zObj;
-    d = reader;
-    this->fileName = fileName;
+	this->zObj = zObj;
+	d = reader;
+	this->fileName = fileName;
 }
 
 // Destruktor
 KSGSLeser::~KSGSLeser()
 {
-    delete dat;
+	delete dat;
 }
 
 // protected
 KSGSLeser::KSGSLeser()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    errorIgnore = 0;
-    this->zObj = 0;
-    d = 0;
-    dat = 0;
-    zeile = 0;
-    mainFuncId = -1;
-    mausFuncId = -1;
-    tastaturFuncId = -1;
-    tickFuncId = -1;
-    renderFuncId = -1;
+	errorIgnore = 0;
+	this->zObj = 0;
+	d = 0;
+	dat = 0;
+	zeile = 0;
+	mainFuncId = -1;
+	mausFuncId = -1;
+	tastaturFuncId = -1;
+	tickFuncId = -1;
+	renderFuncId = -1;
 }
 
-void KSGSLeser::handleError( int beginn, int ende )
+void KSGSLeser::handleError(int beginn, int ende)
 {}
 
-void KSGSLeser::handleKommentar( int beginn, int ende )
+void KSGSLeser::handleKommentar(int beginn, int ende)
 {}
 
-void KSGSLeser::handleString( int beginn, int ende )
+void KSGSLeser::handleString(int beginn, int ende)
 {}
 
 // Script Laden
 bool KSGSLeser::ladeDatei()
 {
-    bool ok = 1;
-    zeile = 1;
-    while( !d->istEnde() )
-    {
-        bool br = 0;
-        int id = leseNext();
-        switch( id )
-        {
-        case -1: // Ende der Datei
-            break;
-        case 1: // Klasse
-            if( 1 )
-            {
-                KSGSLeseKlasse *k = leseKlasse();
-                if( !k )
-                {
-                    error( 6, { "Klasse", fileName }, zObj );
-                    br = 1;
-                }
-                else
-                    dat->klassen.add( k );
-            }
-            break;
-        case 2: // funktion
-            if( 1 )
-            {
-                KSGSLeseFunktion *f = leseFunktion();
-                if( !f )
-                {
-                    error( 6, { "Funktion", fileName }, zObj );
-                    br = 1;
-                }
-                else
-                    dat->funktionen.add( f );
-            }
-            break;
-        case 3: // Variable
-            if( 1 )
-            {
-                KSGSLeseVariable *v = leseVariable();
-                if( !v )
-                {
-                    error( 6, { "Variable", fileName }, zObj );
-                    br = 1;
-                }
-                else
-                    dat->variablen.add( v );
-            }
-            break;
-        case 12: // lesen
-            if( 1 )
-            {
-                if( !leseBis( '(' ) )
-                {
-                    error( 6, { "Lade Anweisung", fileName }, zObj );
-                    br = 1;
-                    break;
-                }
-                d->setLPosition( d->getLPosition() + 1, 0 );
-                if( !leseBis( '"' ) )
-                {
-                    error( 6, { "Lade Anweisung", fileName }, zObj );
-                    br = 1;
-                    break;
-                }
-                d->setLPosition( d->getLPosition() + 1, 0 );
-                __int64 end = nextPosOf( '"', 0 );
-                if( end < 0 )
-                {
-                    error( 6, { "Lade Anweisung", fileName }, zObj );
-                    br = 1;
-                    break;
-                }
-                char *datei = new char[ (int)( end - d->getLPosition() ) + 1 ];
-                datei[ end - d->getLPosition() ] = 0;
-                d->lese( datei, (int)( end - d->getLPosition() ) );
-                Text *dPf = zObj->convertPfad( datei );
-                delete[] datei;
-                if( !leseBis( ')' ) )
-                {
-                    error( 6, { "Lade Anweisung", fileName }, zObj );
-                    br = 1;
-                    break;
-                }
-                d->setLPosition( d->getLPosition() + 1, 0 );
-                Text pf = fileName;
-                fileName.setText( dPf );
-                Datei *dat = new Datei();
-                dat->setDatei( fileName );
-                if( !dat->open( Datei::Style::lesen ) )
-                {
-                    dat->release();
-                    error( 4, { fileName }, zObj );
-                    br = 1;
-                    fileName.setText( pf );
-                    break;
-                }
-                Reader *tmp = d;
-                d = dat;
-                if( !ladeDatei() )
-                {
-                    d = tmp;
-                    error( 6, { "Lade Anweisung", fileName }, zObj );
-                    br = 1;
-                    fileName.setText( pf );
-                    break;
-                }
-                dat->close();
-                dat->release();
-                d = tmp;
-                fileName.setText( pf );
-            }
-            break;
-        default: // Fehler
-            error( 5, { fileName, Text() += zeile }, zObj );
-            br = 1;
-            break;
-        }
-        if( id == -1 )
-            break;
-        if( br )
-        {
-            ok = 0;
-            break;
-        }
-    }
-    d = 0;
-    return ok;
+	bool ok = 1;
+	zeile = 1;
+	while (!d->istEnde())
+	{
+		bool br = 0;
+		int id = leseNext();
+		switch (id)
+		{
+		case -1: // Ende der Datei
+			break;
+		case 1: // Klasse
+			if (1)
+			{
+				KSGSLeseKlasse* k = leseKlasse();
+				if (!k)
+				{
+					error(6, { "Klasse", fileName }, zObj);
+					br = 1;
+				}
+				else
+					dat->klassen.add(k);
+			}
+			break;
+		case 2: // funktion
+			if (1)
+			{
+				KSGSLeseFunktion* f = leseFunktion();
+				if (!f)
+				{
+					error(6, { "Funktion", fileName }, zObj);
+					br = 1;
+				}
+				else
+					dat->funktionen.add(f);
+			}
+			break;
+		case 3: // Variable
+			if (1)
+			{
+				KSGSLeseVariable* v = leseVariable();
+				if (!v)
+				{
+					error(6, { "Variable", fileName }, zObj);
+					br = 1;
+				}
+				else
+					dat->variablen.add(v);
+			}
+			break;
+		case 12: // lesen
+			if (1)
+			{
+				if (!leseBis('('))
+				{
+					error(6, { "Lade Anweisung", fileName }, zObj);
+					br = 1;
+					break;
+				}
+				d->setLPosition(d->getLPosition() + 1, 0);
+				if (!leseBis('"'))
+				{
+					error(6, { "Lade Anweisung", fileName }, zObj);
+					br = 1;
+					break;
+				}
+				d->setLPosition(d->getLPosition() + 1, 0);
+				__int64 end = nextPosOf('"', 0);
+				if (end < 0)
+				{
+					error(6, { "Lade Anweisung", fileName }, zObj);
+					br = 1;
+					break;
+				}
+				char* datei = new char[(int)(end - d->getLPosition()) + 1];
+				datei[end - d->getLPosition()] = 0;
+				d->lese(datei, (int)(end - d->getLPosition()));
+				Text* dPf = zObj->convertPfad(datei);
+				delete[] datei;
+				if (!leseBis(')'))
+				{
+					error(6, { "Lade Anweisung", fileName }, zObj);
+					br = 1;
+					break;
+				}
+				d->setLPosition(d->getLPosition() + 1, 0);
+				Text pf = fileName;
+				fileName.setText(dPf);
+				Datei* dat = new Datei();
+				dat->setDatei(fileName);
+				if (!dat->open(Datei::Style::lesen))
+				{
+					dat->release();
+					error(4, { fileName }, zObj);
+					br = 1;
+					fileName.setText(pf);
+					break;
+				}
+				Reader* tmp = d;
+				d = dat;
+				if (!ladeDatei())
+				{
+					d = tmp;
+					error(6, { "Lade Anweisung", fileName }, zObj);
+					br = 1;
+					fileName.setText(pf);
+					break;
+				}
+				dat->close();
+				dat->release();
+				d = tmp;
+				fileName.setText(pf);
+			}
+			break;
+		default: // Fehler
+			error(5, { fileName, Text() += zeile }, zObj);
+			br = 1;
+			break;
+		}
+		if (id == -1)
+			break;
+		if (br)
+		{
+			ok = 0;
+			break;
+		}
+	}
+	d = 0;
+	return ok;
 }
 
-bool KSGSLeser::leseBis( char c )
+bool KSGSLeser::leseBis(char c)
 {
-    __int64 pos = d->getLPosition();
-    int tmpZ = zeile;
-    char byte = 0;
-    bool kommentar = 0;
-    int kBeg = 0;
-    bool slash = 0;
-    bool gefunden = 0;
-    bool inString = 0;
-    bool inChar = 0;
-    int sBeg = 0;
-    while( !d->istEnde() )
-    {
-        d->lese( &byte, 1 );
-        if( byte == '\n' )
-        {
-            zeile++;
-            if( kommentar )
-                handleKommentar( kBeg, (int)d->getLPosition() );
-            kommentar = 0;
-            continue;
-        }
-        if( byte == '"' && !inChar && !kommentar )
-        {
-            if( inString )
-                handleString( sBeg, (int)d->getLPosition() );
-            inString = !inString;
-            sBeg = (int)d->getLPosition() - 1;
-        }
-        if( byte == '\'' && !inString && !kommentar )
-        {
-            if( inChar )
-                handleString( sBeg, (int)d->getLPosition() );
-            inChar = !inChar;
-            sBeg = (int)d->getLPosition() - 1;
-        }
-        if( byte == '#' )
-        {
-            kBeg = (int)d->getLPosition() - 1;
-            kommentar = 1;
-            continue;
-        }
-        if( byte == '/' )
-        {
-            if( slash )
-            {
-                kBeg = (int)d->getLPosition() - 2;
-                kommentar = 1;
-                slash = 0;
-            }
-            else
-                slash = 1;
-            continue;
-        }
-        else
-            slash = 0;
-        if( byte == c && !kommentar )
-        {
-            gefunden = 1;
-            break;
-        }
-    }
-    if( d->istEnde() && !gefunden )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        d->setLPosition( pos, 0 );
-        zeile = tmpZ;
-        return 0;
-    }
-    d->setLPosition( d->getLPosition() - 1, 0 );
-    return 1;
+	__int64 pos = d->getLPosition();
+	int tmpZ = zeile;
+	char byte = 0;
+	bool kommentar = 0;
+	int kBeg = 0;
+	bool slash = 0;
+	bool gefunden = 0;
+	bool inString = 0;
+	bool inChar = 0;
+	int sBeg = 0;
+	while (!d->istEnde())
+	{
+		d->lese(&byte, 1);
+		if (byte == '\n')
+		{
+			zeile++;
+			if (kommentar)
+				handleKommentar(kBeg, (int)d->getLPosition());
+			kommentar = 0;
+			continue;
+		}
+		if (byte == '"' && !inChar && !kommentar)
+		{
+			if (inString)
+				handleString(sBeg, (int)d->getLPosition());
+			inString = !inString;
+			sBeg = (int)d->getLPosition() - 1;
+		}
+		if (byte == '\'' && !inString && !kommentar)
+		{
+			if (inChar)
+				handleString(sBeg, (int)d->getLPosition());
+			inChar = !inChar;
+			sBeg = (int)d->getLPosition() - 1;
+		}
+		if (byte == '#')
+		{
+			kBeg = (int)d->getLPosition() - 1;
+			kommentar = 1;
+			continue;
+		}
+		if (byte == '/')
+		{
+			if (slash)
+			{
+				kBeg = (int)d->getLPosition() - 2;
+				kommentar = 1;
+				slash = 0;
+			}
+			else
+				slash = 1;
+			continue;
+		}
+		else
+			slash = 0;
+		if (byte == c && !kommentar)
+		{
+			gefunden = 1;
+			break;
+		}
+	}
+	if (d->istEnde() && !gefunden)
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		d->setLPosition(pos, 0);
+		zeile = tmpZ;
+		return 0;
+	}
+	d->setLPosition(d->getLPosition() - 1, 0);
+	return 1;
 }
 
-__int64 KSGSLeser::nextPosOf( char c, char c2 )
+__int64 KSGSLeser::nextPosOf(char c, char c2)
 {
-    __int64 pos = d->getLPosition();
-    char byte = 0;
-    bool kommentar = 0;
-    int kBeg = 0;
-    bool slash = 0;
-    int count = 0;
-    bool gefunden = 0;
-    bool inString = 0;
-    bool inChar = 0;
-    int sBeg = 0;
-    while( !d->istEnde() )
-    {
-        d->lese( &byte, 1 );
-        if( byte == '\n' )
-        {
-            if( kommentar )
-                handleKommentar( kBeg, (int)d->getLPosition() );
-            kommentar = 0;
-            continue;
-        }
-        if( byte == '"' && !inChar && !kommentar )
-        {
-            if( inString )
-                handleString( sBeg, (int)d->getLPosition() );
-            inString = !inString;
-            sBeg = (int)d->getLPosition() - 1;
-        }
-        if( byte == '\'' && !inString && !kommentar )
-        {
-            if( inChar )
-                handleString( sBeg, (int)d->getLPosition() );
-            inChar = !inChar;
-            sBeg = (int)d->getLPosition() - 1;
-        }
-        if( byte == '#' )
-        {
-            kBeg = (int)d->getLPosition() - 1;
-            kommentar = 1;
-            continue;
-        }
-        if( byte == '/' )
-        {
-            if( slash )
-            {
-                kBeg = (int)d->getLPosition() - 2;
-                kommentar = 1;
-                slash = 0;
-            }
-            else
-                slash = 1;
-            continue;
-        }
-        else
-            slash = 0;
-        if( !kommentar )
-        {
-            if( byte == c2 )
-            {
-                count++;
-                continue;
-            }
-            if( byte == c )
-            {
-                if( !count )
-                {
-                    gefunden = 1;
-                    break;
-                }
-                count--;
-                continue;
-            }
-        }
-    }
-    if( d->istEnde() && !gefunden )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        d->setLPosition( pos, 0 );
-        return -1;
-    }
-    __int64 ret = d->getLPosition() - 1;
-    d->setLPosition( pos, 0 );
-    return ret;
+	__int64 pos = d->getLPosition();
+	char byte = 0;
+	bool kommentar = 0;
+	int kBeg = 0;
+	bool slash = 0;
+	int count = 0;
+	bool gefunden = 0;
+	bool inString = 0;
+	bool inChar = 0;
+	int sBeg = 0;
+	while (!d->istEnde())
+	{
+		d->lese(&byte, 1);
+		if (byte == '\n')
+		{
+			if (kommentar)
+				handleKommentar(kBeg, (int)d->getLPosition());
+			kommentar = 0;
+			continue;
+		}
+		if (byte == '"' && !inChar && !kommentar)
+		{
+			if (inString)
+				handleString(sBeg, (int)d->getLPosition());
+			inString = !inString;
+			sBeg = (int)d->getLPosition() - 1;
+		}
+		if (byte == '\'' && !inString && !kommentar)
+		{
+			if (inChar)
+				handleString(sBeg, (int)d->getLPosition());
+			inChar = !inChar;
+			sBeg = (int)d->getLPosition() - 1;
+		}
+		if (byte == '#')
+		{
+			kBeg = (int)d->getLPosition() - 1;
+			kommentar = 1;
+			continue;
+		}
+		if (byte == '/')
+		{
+			if (slash)
+			{
+				kBeg = (int)d->getLPosition() - 2;
+				kommentar = 1;
+				slash = 0;
+			}
+			else
+				slash = 1;
+			continue;
+		}
+		else
+			slash = 0;
+		if (!kommentar)
+		{
+			if (byte == c2)
+			{
+				count++;
+				continue;
+			}
+			if (byte == c)
+			{
+				if (!count)
+				{
+					gefunden = 1;
+					break;
+				}
+				count--;
+				continue;
+			}
+		}
+	}
+	if (d->istEnde() && !gefunden)
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		d->setLPosition(pos, 0);
+		return -1;
+	}
+	__int64 ret = d->getLPosition() - 1;
+	d->setLPosition(pos, 0);
+	return ret;
 }
 
 bool KSGSLeser::leseBisText()
 {
-    __int64 pos = d->getLPosition();
-    char c = 0;
-    bool kommentar = 0;
-    int kBeg = 0;
-    bool slash = 0;
-    bool gefunden = 0;
-    bool inString = 0;
-    bool inChar = 0;
-    int sBeg = 0;
-    while( !d->istEnde() )
-    {
-        d->lese( &c, 1 );
-        if( c == '\n' )
-        {
-            zeile++;
-            if( kommentar )
-                handleKommentar( kBeg, (int)d->getLPosition() );
-            kommentar = 0;
-            continue;
-        }
-        if( c == '"' && !inChar && !kommentar )
-        {
-            if( inString )
-                handleString( sBeg, (int)d->getLPosition() );
-            inString = !inString;
-            sBeg = (int)d->getLPosition() - 1;
-        }
-        if( c == '\'' && !inString && !kommentar )
-        {
-            if( inChar )
-                handleString( sBeg, (int)d->getLPosition() );
-            inChar = !inChar;
-            sBeg = (int)d->getLPosition() - 1;
-        }
-        if( c == '#' )
-        {
-            kBeg = (int)d->getLPosition() - 1;
-            kommentar = 1;
-            continue;
-        }
-        if( c == '/' )
-        {
-            if( slash )
-            {
-                kBeg = (int)d->getLPosition() - 2;
-                kommentar = 1;
-                slash = 0;
-            }
-            else
-                slash = 1;
-            continue;
-        }
-        else
-            slash = 0;
-        if( !istLehr( c ) && !kommentar )
-        {
-            gefunden = 1;
-            break;
-        }
-    }
-    if( d->istEnde() && !gefunden )
-    {
-        d->setLPosition( pos, 0 );
-        return 0;
-    }
-    d->setLPosition( d->getLPosition() - 1, 0 );
-    return 1;
+	__int64 pos = d->getLPosition();
+	char c = 0;
+	bool kommentar = 0;
+	int kBeg = 0;
+	bool slash = 0;
+	bool gefunden = 0;
+	bool inString = 0;
+	bool inChar = 0;
+	int sBeg = 0;
+	while (!d->istEnde())
+	{
+		d->lese(&c, 1);
+		if (c == '\n')
+		{
+			zeile++;
+			if (kommentar)
+				handleKommentar(kBeg, (int)d->getLPosition());
+			kommentar = 0;
+			continue;
+		}
+		if (c == '"' && !inChar && !kommentar)
+		{
+			if (inString)
+				handleString(sBeg, (int)d->getLPosition());
+			inString = !inString;
+			sBeg = (int)d->getLPosition() - 1;
+		}
+		if (c == '\'' && !inString && !kommentar)
+		{
+			if (inChar)
+				handleString(sBeg, (int)d->getLPosition());
+			inChar = !inChar;
+			sBeg = (int)d->getLPosition() - 1;
+		}
+		if (c == '#')
+		{
+			kBeg = (int)d->getLPosition() - 1;
+			kommentar = 1;
+			continue;
+		}
+		if (c == '/')
+		{
+			if (slash)
+			{
+				kBeg = (int)d->getLPosition() - 2;
+				kommentar = 1;
+				slash = 0;
+			}
+			else
+				slash = 1;
+			continue;
+		}
+		else
+			slash = 0;
+		if (!istLehr(c) && !kommentar)
+		{
+			gefunden = 1;
+			break;
+		}
+	}
+	if (d->istEnde() && !gefunden)
+	{
+		d->setLPosition(pos, 0);
+		return 0;
+	}
+	d->setLPosition(d->getLPosition() - 1, 0);
+	return 1;
 }
 
 int KSGSLeser::leseNext()
 {
-    if( !leseBisText() )
-        return -1;
-    __int64 pos = d->getLPosition();
-    int ret = 0;
-    Text txt = "";
-    char byte[] = { 0, 0 };
-    d->lese( byte, 1 );
-    while( !istTrenner( byte[ 0 ] ) && !d->istEnde() )
-    {
-        txt.append( byte );
-        d->lese( byte, 1 );
-    }
-    if( d->istEnde() || !txt.getLength() )
-    {
-        d->setLPosition( pos, 0 );
-        return -1;
-    }
-    if( txt.istGleich( "class" ) )
-        ret = 1;
-    if( txt.istGleich( "func" ) )
-        ret = 2;
-    if( txt.istGleich( "var" ) )
-        ret = 3;
-    if( txt.istGleich( "public" ) )
-        ret = 4;
-    if( txt.istGleich( "private" ) )
-        ret = 5;
-    if( txt.istGleich( "if" ) )
-        ret = 6;
-    if( txt.istGleich( "for" ) )
-        ret = 7;
-    if( txt.istGleich( "while" ) )
-        ret = 8;
-    if( txt.istGleich( "return" ) )
-        ret = 9;
-    if( txt.istGleich( "break" ) )
-        ret = 10;
-    if( txt.istGleich( "continue" ) )
-        ret = 11;
-    if( txt.istGleich( "lesen" ) )
-        ret = 12;
-    d->setLPosition( pos, 0 );
-    return ret;
+	if (!leseBisText())
+		return -1;
+	__int64 pos = d->getLPosition();
+	int ret = 0;
+	Text txt = "";
+	char byte[] = { 0, 0 };
+	d->lese(byte, 1);
+	while (!istTrenner(byte[0]) && !d->istEnde())
+	{
+		txt.append(byte);
+		d->lese(byte, 1);
+	}
+	if (d->istEnde() || !txt.getLength())
+	{
+		d->setLPosition(pos, 0);
+		return -1;
+	}
+	if (txt.istGleich("class"))
+		ret = 1;
+	if (txt.istGleich("func"))
+		ret = 2;
+	if (txt.istGleich("var"))
+		ret = 3;
+	if (txt.istGleich("public"))
+		ret = 4;
+	if (txt.istGleich("private"))
+		ret = 5;
+	if (txt.istGleich("if"))
+		ret = 6;
+	if (txt.istGleich("for"))
+		ret = 7;
+	if (txt.istGleich("while"))
+		ret = 8;
+	if (txt.istGleich("return"))
+		ret = 9;
+	if (txt.istGleich("break"))
+		ret = 10;
+	if (txt.istGleich("continue"))
+		ret = 11;
+	if (txt.istGleich("lesen"))
+		ret = 12;
+	d->setLPosition(pos, 0);
+	return ret;
 }
 
-bool KSGSLeser::istTrenner( char c )
+bool KSGSLeser::istTrenner(char c)
 {
-    return !( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) || ( c >= '0' && c <= '9' )
-              || c == '_' || c == 'ä' || c == 'ö' || c == 'ü' || c == 'Ä' || c == 'Ö' || c == 'Ü' || c == 'ß' );
+	return !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+		|| c == '_' || c == 'ä' || c == 'ö' || c == 'ü' || c == 'Ä' || c == 'Ö' || c == 'Ü' || c == 'ß');
 }
 
-bool KSGSLeser::istLehr( char c )
+bool KSGSLeser::istLehr(char c)
 {
-    return c == ' ' || c == '\n' || c == '\r' || c == '\t';
+	return c == ' ' || c == '\n' || c == '\r' || c == '\t';
 }
 
-KSGSLeseKlasse *KSGSLeser::leseKlasse()
+KSGSLeseKlasse* KSGSLeser::leseKlasse()
 {
-    KSGSLeseKlasse *ret = new KSGSLeseKlasse();
-    ret->debug.datei.setText( fileName );
-    ret->debug.zeile = zeile;
-    d->setLPosition( d->getLPosition() + 5, 0 ); // 'class' überspringen
-    if( !leseBisText() ) // Bis zum beginn des Klassennamens lesen
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        ret->release();
-        return 0;
-    }
-    char byte[] = { 0, 0 }; // Klassenname lesen
-    d->lese( byte, 1 );
-    while( !istTrenner( *byte ) )
-    {
-        ret->name.append( byte );
-        d->lese( byte, 1 );
-    }
-    if( !leseBis( '{' ) ) // Bis zum beginn der Klasse lesen
-    {
-        ret->release();
-        return 0;
-    }
-    d->setLPosition( d->getLPosition() + 1, 0 );
-    bool sichtbar = 0;
-    __int64 ende = nextPosOf( '}', '{' ); // Ende der Klasse
-    if( ende < 0 )
-    {
-        ret->release();
-        return 0;
-    }
-    while( d->getLPosition() < ende ) // Inhalt der Klasse lesen
-    {
-        int id = leseNext();
-        if( id == -1 )
-            break;
-        switch( id )
-        {
-        case 2: // Funktion
-            if( 1 )
-            {
-                KSGSLeseFunktion *f = leseFunktion();
-                if( !f )
-                {
-                    ret->release();
-                    return 0;
-                }
-                ret->funktionen.add( f );
-                ret->fSichtbar.add( sichtbar );
-            }
-            break;
-        case 3: // Variable
-            if( 1 )
-            {
-                KSGSLeseVariable *v = leseVariable();
-                if( !v )
-                {
-                    ret->release();
-                    return 0;
-                }
-                ret->variablen.add( v );
-                ret->vSichtbar.add( sichtbar );
-            }
-            break;
-        case 4: // public
-            sichtbar = 1;
-            d->setLPosition( d->getLPosition() + 6, 0 );
-            if( !leseBis( ':' ) )
-            {
-                ret->release();
-                return 0;
-            }
-            d->setLPosition( d->getLPosition() + 1, 0 );
-            break;
-        case 5: // private
-            sichtbar = 0;
-            d->setLPosition( d->getLPosition() + 7, 0 );
-            if( !leseBis( ':' ) )
-            {
-                ret->release();
-                return 0;
-            }
-            d->setLPosition( d->getLPosition() + 1, 0 );
-            break;
-        default:
-            ret->release();
-            return 0;
-        }
-    }
-    if( d->getLPosition() > ende )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        ret->release();
-        return 0;
-    }
-    d->setLPosition( ende + 1, 0 );
-    if( !leseBis( ';' ) ) // ';' Nach einer Klasse überlesen
-    {
-        ret->release();
-        return 0;
-    }
-    d->setLPosition( d->getLPosition() + 1, 0 );
-    return ret;
+	KSGSLeseKlasse* ret = new KSGSLeseKlasse();
+	ret->debug.datei.setText(fileName);
+	ret->debug.zeile = zeile;
+	d->setLPosition(d->getLPosition() + 5, 0); // 'class' überspringen
+	if (!leseBisText()) // Bis zum beginn des Klassennamens lesen
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		ret->release();
+		return 0;
+	}
+	char byte[] = { 0, 0 }; // Klassenname lesen
+	d->lese(byte, 1);
+	while (!istTrenner(*byte))
+	{
+		ret->name.append(byte);
+		d->lese(byte, 1);
+	}
+	if (!leseBis('{')) // Bis zum beginn der Klasse lesen
+	{
+		ret->release();
+		return 0;
+	}
+	d->setLPosition(d->getLPosition() + 1, 0);
+	bool sichtbar = 0;
+	__int64 ende = nextPosOf('}', '{'); // Ende der Klasse
+	if (ende < 0)
+	{
+		ret->release();
+		return 0;
+	}
+	while (d->getLPosition() < ende) // Inhalt der Klasse lesen
+	{
+		int id = leseNext();
+		if (id == -1)
+			break;
+		switch (id)
+		{
+		case 2: // Funktion
+			if (1)
+			{
+				KSGSLeseFunktion* f = leseFunktion();
+				if (!f)
+				{
+					ret->release();
+					return 0;
+				}
+				ret->funktionen.add(f);
+				ret->fSichtbar.add(sichtbar);
+			}
+			break;
+		case 3: // Variable
+			if (1)
+			{
+				KSGSLeseVariable* v = leseVariable();
+				if (!v)
+				{
+					ret->release();
+					return 0;
+				}
+				ret->variablen.add(v);
+				ret->vSichtbar.add(sichtbar);
+			}
+			break;
+		case 4: // public
+			sichtbar = 1;
+			d->setLPosition(d->getLPosition() + 6, 0);
+			if (!leseBis(':'))
+			{
+				ret->release();
+				return 0;
+			}
+			d->setLPosition(d->getLPosition() + 1, 0);
+			break;
+		case 5: // private
+			sichtbar = 0;
+			d->setLPosition(d->getLPosition() + 7, 0);
+			if (!leseBis(':'))
+			{
+				ret->release();
+				return 0;
+			}
+			d->setLPosition(d->getLPosition() + 1, 0);
+			break;
+		default:
+			ret->release();
+			return 0;
+		}
+	}
+	if (d->getLPosition() > ende)
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		ret->release();
+		return 0;
+	}
+	d->setLPosition(ende + 1, 0);
+	if (!leseBis(';')) // ';' Nach einer Klasse überlesen
+	{
+		ret->release();
+		return 0;
+	}
+	d->setLPosition(d->getLPosition() + 1, 0);
+	return ret;
 }
 
-KSGSLeseFunktion *KSGSLeser::leseFunktion()
+KSGSLeseFunktion* KSGSLeser::leseFunktion()
 {
-    KSGSLeseFunktion *ret = new KSGSLeseFunktion();
-    ret->debug.datei.setText( fileName );
-    ret->debug.zeile = zeile;
-    d->setLPosition( d->getLPosition() + 4, 0 ); // 'func' überspringen
-    if( !leseBisText() )
-    {
-        ret->release();
-        return 0;
-    }
-    char byte[] = { 0, 0 }; // Rückgabetyp der Funktion lesen
-    d->lese( byte, 1 );
-    while( !istTrenner( *byte ) )
-    {
-        ret->typ.append( byte );
-        d->lese( byte, 1 );
-    }
-    d->setLPosition( d->getLPosition() - 1, 0 );
-    if( !leseBisText() )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        ret->release();
-        return 0;
-    }
-    d->lese( byte, 1 ); // Name der Funktion lesen
-    while( !istTrenner( *byte ) )
-    {
-        ret->name.append( byte );
-        d->lese( byte, 1 );
-    }
-    d->setLPosition( d->getLPosition() - 1, 0 );
-    if( !leseBis( '(' ) ) // Parameterbeginn
-    {
-        ret->release();
-        return 0;
-    }
-    d->setLPosition( d->getLPosition() + 1, 0 );
-    __int64 paramEnde = nextPosOf( ')', '(' );
-    if( paramEnde < 0 )
-    {
-        ret->release();
-        return 0;
-    }
-    while( d->getLPosition() < paramEnde )
-    {
-        KSGSLeseVariable *param = leseVariable( 1 ); // Übergabeparameter einlesen
-        if( !param )
-            break;
-        ret->parameter.add( param );
-    }
-    d->setLPosition( paramEnde + 1, 0 );
-    if( !leseBis( '{' ) ) // Funktionsrumpf beginn
-    {
-        ret->release();
-        return 0;
-    }
-    d->setLPosition( d->getLPosition() + 1, 0 );
-    __int64 funkEnde = nextPosOf( '}', '{' ); // Ende der Funktion
-    if( funkEnde < 0 )
-    {
-        ret->release();
-        return 0;
-    }
-    while( d->getLPosition() < funkEnde )
-    {
-        KSGSLeseBefehl *bef = leseBefehl(); // Befehle einlesen
-        if( !bef )
-            break;
-        else
-            ret->befehle.add( bef );
-        if( !leseBisText() )
-        {
-            ret->release();
-            return 0;
-        }
-    }
-    d->setLPosition( funkEnde + 1, 0 ); // '}' am ende der Funktion überlesen
-    return ret;
+	KSGSLeseFunktion* ret = new KSGSLeseFunktion();
+	ret->debug.datei.setText(fileName);
+	ret->debug.zeile = zeile;
+	d->setLPosition(d->getLPosition() + 4, 0); // 'func' überspringen
+	if (!leseBisText())
+	{
+		ret->release();
+		return 0;
+	}
+	char byte[] = { 0, 0 }; // Rückgabetyp der Funktion lesen
+	d->lese(byte, 1);
+	while (!istTrenner(*byte))
+	{
+		ret->typ.append(byte);
+		d->lese(byte, 1);
+	}
+	d->setLPosition(d->getLPosition() - 1, 0);
+	if (!leseBisText())
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		ret->release();
+		return 0;
+	}
+	d->lese(byte, 1); // Name der Funktion lesen
+	while (!istTrenner(*byte))
+	{
+		ret->name.append(byte);
+		d->lese(byte, 1);
+	}
+	d->setLPosition(d->getLPosition() - 1, 0);
+	if (!leseBis('(')) // Parameterbeginn
+	{
+		ret->release();
+		return 0;
+	}
+	d->setLPosition(d->getLPosition() + 1, 0);
+	__int64 paramEnde = nextPosOf(')', '(');
+	if (paramEnde < 0)
+	{
+		ret->release();
+		return 0;
+	}
+	while (d->getLPosition() < paramEnde)
+	{
+		KSGSLeseVariable* param = leseVariable(1); // Übergabeparameter einlesen
+		if (!param)
+			break;
+		ret->parameter.add(param);
+	}
+	d->setLPosition(paramEnde + 1, 0);
+	if (!leseBis('{')) // Funktionsrumpf beginn
+	{
+		ret->release();
+		return 0;
+	}
+	d->setLPosition(d->getLPosition() + 1, 0);
+	__int64 funkEnde = nextPosOf('}', '{'); // Ende der Funktion
+	if (funkEnde < 0)
+	{
+		ret->release();
+		return 0;
+	}
+	while (d->getLPosition() < funkEnde)
+	{
+		KSGSLeseBefehl* bef = leseBefehl(); // Befehle einlesen
+		if (!bef)
+			break;
+		else
+			ret->befehle.add(bef);
+		if (!leseBisText())
+		{
+			ret->release();
+			return 0;
+		}
+	}
+	d->setLPosition(funkEnde + 1, 0); // '}' am ende der Funktion überlesen
+	return ret;
 }
 
-KSGSLeseVariable *KSGSLeser::leseVariable( bool param )
+KSGSLeseVariable* KSGSLeser::leseVariable(bool param)
 {
-    KSGSLeseVariable *ret = new KSGSLeseVariable();
-    ret->debug.datei.setText( fileName );
-    ret->debug.zeile = zeile;
-    if( !param )
-        d->setLPosition( d->getLPosition() + 3, 0 ); // 'var' überspringen
-    __int64 endPos = 0;
-    if( param )
-    {
-        endPos = nextPosOf( ')', 0 );
-        if( endPos < 0 )
-        {
-            handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-            delete ret;
-            return 0;
-        }
-    }
-    if( !leseBisText() )
-    {
-        delete ret;
-        return 0;
-    }
-    if( param && d->getLPosition() >= endPos )
-    {
-        delete ret;
-        return 0;
-    }
-    char byte[] = { 0, 0 }; // Variablentyp lesen
-    d->lese( byte, 1 );
-    while( !istTrenner( *byte ) )
-    {
-        ret->typ.append( byte );
-        d->lese( byte, 1 );
-    }
-    d->setLPosition( d->getLPosition() - 1, 0 );
-    if( !leseBisText() )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        delete ret;
-        return 0;
-    }
-    d->lese( byte, 1 ); // Variablenname lesen
-    while( !istTrenner( *byte ) )
-    {
-        ret->name.append( byte );
-        d->lese( byte, 1 );
-    }
-    d->setLPosition( d->getLPosition() - 1, 0 );
-    __int64 ende = nextPosOf( ';', 0 );
-    if( ende < 0 )
-    {
-        delete ret;
-        return 0;
-    }
-    if( param )
-    {
-        errorIgnore = 1;
-        __int64 tmp = nextPosOf( ',', 0 );
-        errorIgnore = 0;
-        if( tmp >= 0 && tmp < endPos )
-            ende = tmp;
-        else
-            ende = endPos;
-    }
-    errorIgnore = 1;
-    __int64 gleich = nextPosOf( '=', 0 );
-    errorIgnore = 0;
-    if( gleich < ende && gleich >= 0 ) // prüfen ob die variable gesetzt wird
-    {
-        if( !leseBis( '=' ) )
-        {
-            delete ret;
-            return 0;
-        }
-        d->setLPosition( d->getLPosition() + 1, 0 );
-    }
-    if( leseBisText() )
-    {
-        if( d->getLPosition() < ende )
-        {
-            while( d->getLPosition() < ende ) // Wert der Variable lesen
-            {
-                d->lese( byte, 1 );
-                ret->wert.append( byte );
-            }
-        }
-    }
-    while( istLehr( ret->wert.getText()[ ret->wert.getLength() - 1 ] ) && ret->wert.getLength() > 0 )
-    {
-        if( ret->wert.getText()[ ret->wert.getLength() - 1 ] == '\n' )
-            zeile++;
-        if( !( ret->wert.getLength() - 1 ) )
-        {
-            ret->wert.setText( "" );
-            break;
-        }
-        ret->wert.setText( ret->wert.getText(), ret->wert.getLength() - 1 );
-    }
-    if( d->getLPosition() > ende )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        delete ret;
-        return 0;
-    }
-    d->setLPosition( ende + 1, 0 ); // ';' oder bei param ')' oder ',' am Ende überlesen
-    return ret;
+	KSGSLeseVariable* ret = new KSGSLeseVariable();
+	ret->debug.datei.setText(fileName);
+	ret->debug.zeile = zeile;
+	if (!param)
+		d->setLPosition(d->getLPosition() + 3, 0); // 'var' überspringen
+	__int64 endPos = 0;
+	if (param)
+	{
+		endPos = nextPosOf(')', 0);
+		if (endPos < 0)
+		{
+			handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+			delete ret;
+			return 0;
+		}
+	}
+	if (!leseBisText())
+	{
+		delete ret;
+		return 0;
+	}
+	if (param && d->getLPosition() >= endPos)
+	{
+		delete ret;
+		return 0;
+	}
+	char byte[] = { 0, 0 }; // Variablentyp lesen
+	d->lese(byte, 1);
+	while (!istTrenner(*byte))
+	{
+		ret->typ.append(byte);
+		d->lese(byte, 1);
+	}
+	d->setLPosition(d->getLPosition() - 1, 0);
+	if (!leseBisText())
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		delete ret;
+		return 0;
+	}
+	d->lese(byte, 1); // Variablenname lesen
+	while (!istTrenner(*byte))
+	{
+		ret->name.append(byte);
+		d->lese(byte, 1);
+	}
+	d->setLPosition(d->getLPosition() - 1, 0);
+	__int64 ende = nextPosOf(';', 0);
+	if (ende < 0)
+	{
+		delete ret;
+		return 0;
+	}
+	if (param)
+	{
+		errorIgnore = 1;
+		__int64 tmp = nextPosOf(',', 0);
+		errorIgnore = 0;
+		if (tmp >= 0 && tmp < endPos)
+			ende = tmp;
+		else
+			ende = endPos;
+	}
+	errorIgnore = 1;
+	__int64 gleich = nextPosOf('=', 0);
+	errorIgnore = 0;
+	if (gleich < ende && gleich >= 0) // prüfen ob die variable gesetzt wird
+	{
+		if (!leseBis('='))
+		{
+			delete ret;
+			return 0;
+		}
+		d->setLPosition(d->getLPosition() + 1, 0);
+	}
+	if (leseBisText())
+	{
+		if (d->getLPosition() < ende)
+		{
+			while (d->getLPosition() < ende) // Wert der Variable lesen
+			{
+				d->lese(byte, 1);
+				ret->wert.append(byte);
+			}
+		}
+	}
+	while (istLehr(ret->wert.getText()[ret->wert.getLength() - 1]) && ret->wert.getLength() > 0)
+	{
+		if (ret->wert.getText()[ret->wert.getLength() - 1] == '\n')
+			zeile++;
+		if (!(ret->wert.getLength() - 1))
+		{
+			ret->wert.setText("");
+			break;
+		}
+		ret->wert.setText(ret->wert.getText(), ret->wert.getLength() - 1);
+	}
+	if (d->getLPosition() > ende)
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		delete ret;
+		return 0;
+	}
+	d->setLPosition(ende + 1, 0); // ';' oder bei param ')' oder ',' am Ende überlesen
+	return ret;
 }
 
-KSGSLeseBefehl *KSGSLeser::leseBefehl()
+KSGSLeseBefehl* KSGSLeser::leseBefehl()
 {
-    __int64 fEnde = nextPosOf( '}', '{' );
-    if( fEnde < 0 )
-        return 0;
-    int typ = leseNext();
-    if( typ < 0 )
-        return 0;
-    KSGSLeseBefehl *ret = new KSGSLeseBefehl();
-    ret->debug.datei.setText( fileName );
-    ret->debug.zeile = zeile;
-    ret->typ = typ;
-    switch( typ )
-    {
-    case 0:
-    case 3: // var
-        if( 1 )
-        {
-            __int64 endPos = nextPosOf( ';', 0 );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            int len = (int)( endPos - d->getLPosition() );
-            if( len )
-            {
-                char *txt = new char[ len + 1 ];
-                txt[ len ] = 0;
-                d->lese( txt, len );
-                ret->befehl = txt;
-                delete[] txt;
-            }
-            d->setLPosition( endPos + 1, 0 );
-        }
-        break;
-    case 6: // if
-        if( 1 )
-        {
-            if( !leseBis( '(' ) )
-            {
-                delete ret;
-                return 0;
-            }
-            d->setLPosition( d->getLPosition() + 1, 0 );
-            __int64 endPos = nextPosOf( ')', '(' );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            int len = (int)( endPos - d->getLPosition() );
-            if( len )
-            {
-                char *txt = new char[ len + 1 ];
-                txt[ len ] = 0;
-                d->lese( txt, len );
-                ret->befehl = txt;
-                delete[] txt;
-            }
-            d->setLPosition( endPos + 1, 0 );
-            if( !leseBis( '{' ) )
-            {
-                delete ret;
-                return 0;
-            }
-            d->setLPosition( d->getLPosition() + 1, 0 );
-            endPos = nextPosOf( '}', '{' );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            while( d->getLPosition() < endPos )
-            {
-                KSGSLeseBefehl *tmp = leseBefehl();
-                if( !tmp )
-                    break;
-                else
-                    ret->listA.add( tmp );
-            }
-            d->setLPosition( endPos + 1, 0 );
-            int tmpZ = zeile;
-            if( !leseBisText() )
-            {
-                handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-                delete ret;
-                return 0;
-            }
-            char *el = new char[ 5 ];
-            if( d->getLPosition() + 4 <= fEnde )
-                d->lese( el, 4 );
-            else
-                el[ 0 ] = 0;
-            el[ 4 ] = 0;
-            if( Text( "else" ).istGleich( el ) )
-            {
-                if( !leseBis( '{' ) )
-                {
-                    delete ret;
-                    return 0;
-                }
-                d->setLPosition( d->getLPosition() + 1, 0 );
-                endPos = nextPosOf( '}', '{' );
-                if( endPos < 0 )
-                {
-                    delete ret;
-                    return 0;
-                }
-                while( d->getLPosition() < endPos )
-                {
-                    KSGSLeseBefehl *tmp = leseBefehl();
-                    if( !tmp )
-                        break;
-                    else
-                        ret->listB.add( tmp );
-                }
-                d->setLPosition( endPos + 1, 0 );
-            }
-            else
-            {
-                d->setLPosition( endPos + 1, 0 );
-                zeile = tmpZ;
-            }
-            delete[] el;
-        }
-        break;
-    case 7: // for
-    case 8: // while
-        if( 1 )
-        {
-            if( !leseBis( '(' ) )
-            {
-                delete ret;
-                return 0;
-            }
-            d->setLPosition( d->getLPosition() + 1, 0 );
-            __int64 endPos = nextPosOf( ')', '(' );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            int len = (int)( endPos - d->getLPosition() );
-            if( len )
-            {
-                char *txt = new char[ len + 1 ];
-                txt[ len ] = 0;
-                d->lese( txt, len );
-                ret->befehl = txt;
-                delete[] txt;
-            }
-            d->setLPosition( endPos + 1, 0 );
-            if( !leseBis( '{' ) )
-            {
-                delete ret;
-                return 0;
-            }
-            d->setLPosition( d->getLPosition() + 1, 0 );
-            endPos = nextPosOf( '}', '{' );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            while( d->getLPosition() < endPos )
-            {
-                KSGSLeseBefehl *tmp = leseBefehl();
-                if( !tmp )
-                    break;
-                else
-                    ret->listA.add( tmp );
-            }
-            d->setLPosition( endPos + 1, 0 );
-        }
-        break;
-    case 9: // return
-        if( 1 )
-        {
-            __int64 endPos = nextPosOf( ';', 0 );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            int len = (int)( endPos - d->getLPosition() );
-            if( len )
-            {
-                char *txt = new char[ len + 1 ];
-                txt[ len ] = 0;
-                d->lese( txt, len );
-                ret->befehl = txt;
-                delete[] txt;
-            }
-            d->setLPosition( endPos + 1, 0 );
-        }
-        break;
-    case 10: // break
-    case 11: // continue
-        if( 1 )
-        {
-            __int64 endPos = nextPosOf( ';', 0 );
-            if( endPos < 0 )
-            {
-                delete ret;
-                return 0;
-            }
-            d->setLPosition( endPos + 1, 0 );
-        }
-        break;
-    default:
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        delete ret;
-        return 0;
-    }
-    if( d->getLPosition() > fEnde )
-    {
-        handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
-        delete ret;
-        return 0;
-    }
-    ret->befehl.ersetzen( "->", "." );
-    return ret;
+	__int64 fEnde = nextPosOf('}', '{');
+	if (fEnde < 0)
+		return 0;
+	int typ = leseNext();
+	if (typ < 0)
+		return 0;
+	KSGSLeseBefehl* ret = new KSGSLeseBefehl();
+	ret->debug.datei.setText(fileName);
+	ret->debug.zeile = zeile;
+	ret->typ = typ;
+	switch (typ)
+	{
+	case 0:
+	case 3: // var
+		if (1)
+		{
+			__int64 endPos = nextPosOf(';', 0);
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			int len = (int)(endPos - d->getLPosition());
+			if (len)
+			{
+				char* txt = new char[len + 1];
+				txt[len] = 0;
+				d->lese(txt, len);
+				ret->befehl = txt;
+				delete[] txt;
+			}
+			d->setLPosition(endPos + 1, 0);
+		}
+		break;
+	case 6: // if
+		if (1)
+		{
+			if (!leseBis('('))
+			{
+				delete ret;
+				return 0;
+			}
+			d->setLPosition(d->getLPosition() + 1, 0);
+			__int64 endPos = nextPosOf(')', '(');
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			int len = (int)(endPos - d->getLPosition());
+			if (len)
+			{
+				char* txt = new char[len + 1];
+				txt[len] = 0;
+				d->lese(txt, len);
+				ret->befehl = txt;
+				delete[] txt;
+			}
+			d->setLPosition(endPos + 1, 0);
+			if (!leseBis('{'))
+			{
+				delete ret;
+				return 0;
+			}
+			d->setLPosition(d->getLPosition() + 1, 0);
+			endPos = nextPosOf('}', '{');
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			while (d->getLPosition() < endPos)
+			{
+				KSGSLeseBefehl* tmp = leseBefehl();
+				if (!tmp)
+					break;
+				else
+					ret->listA.add(tmp);
+			}
+			d->setLPosition(endPos + 1, 0);
+			int tmpZ = zeile;
+			if (!leseBisText())
+			{
+				handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+				delete ret;
+				return 0;
+			}
+			char* el = new char[5];
+			if (d->getLPosition() + 4 <= fEnde)
+				d->lese(el, 4);
+			else
+				el[0] = 0;
+			el[4] = 0;
+			if (Text("else").istGleich(el))
+			{
+				if (!leseBis('{'))
+				{
+					delete ret;
+					return 0;
+				}
+				d->setLPosition(d->getLPosition() + 1, 0);
+				endPos = nextPosOf('}', '{');
+				if (endPos < 0)
+				{
+					delete ret;
+					return 0;
+				}
+				while (d->getLPosition() < endPos)
+				{
+					KSGSLeseBefehl* tmp = leseBefehl();
+					if (!tmp)
+						break;
+					else
+						ret->listB.add(tmp);
+				}
+				d->setLPosition(endPos + 1, 0);
+			}
+			else
+			{
+				d->setLPosition(endPos + 1, 0);
+				zeile = tmpZ;
+			}
+			delete[] el;
+		}
+		break;
+	case 7: // for
+	case 8: // while
+		if (1)
+		{
+			if (!leseBis('('))
+			{
+				delete ret;
+				return 0;
+			}
+			d->setLPosition(d->getLPosition() + 1, 0);
+			__int64 endPos = nextPosOf(')', '(');
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			int len = (int)(endPos - d->getLPosition());
+			if (len)
+			{
+				char* txt = new char[len + 1];
+				txt[len] = 0;
+				d->lese(txt, len);
+				ret->befehl = txt;
+				delete[] txt;
+			}
+			d->setLPosition(endPos + 1, 0);
+			if (!leseBis('{'))
+			{
+				delete ret;
+				return 0;
+			}
+			d->setLPosition(d->getLPosition() + 1, 0);
+			endPos = nextPosOf('}', '{');
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			while (d->getLPosition() < endPos)
+			{
+				KSGSLeseBefehl* tmp = leseBefehl();
+				if (!tmp)
+					break;
+				else
+					ret->listA.add(tmp);
+			}
+			d->setLPosition(endPos + 1, 0);
+		}
+		break;
+	case 9: // return
+		if (1)
+		{
+			__int64 endPos = nextPosOf(';', 0);
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			int len = (int)(endPos - d->getLPosition());
+			if (len)
+			{
+				char* txt = new char[len + 1];
+				txt[len] = 0;
+				d->lese(txt, len);
+				ret->befehl = txt;
+				delete[] txt;
+			}
+			d->setLPosition(endPos + 1, 0);
+		}
+		break;
+	case 10: // break
+	case 11: // continue
+		if (1)
+		{
+			__int64 endPos = nextPosOf(';', 0);
+			if (endPos < 0)
+			{
+				delete ret;
+				return 0;
+			}
+			d->setLPosition(endPos + 1, 0);
+		}
+		break;
+	default:
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		delete ret;
+		return 0;
+	}
+	if (d->getLPosition() > fEnde)
+	{
+		handleError((int)d->getLPosition() - 1, (int)d->getLPosition());
+		delete ret;
+		return 0;
+	}
+	ret->befehl.ersetzen("->", ".");
+	return ret;
 }
 
 // Script Compilieren
-bool KSGSLeser::compileKlasse( KSGSLeseKlasse *zLK, KSGSCompKlassTable *zKT )
+bool KSGSLeser::compileKlasse(KSGSLeseKlasse* zLK, KSGSCompKlassTable* zKT)
 {
-    if( !zKT->hat( (char *)zLK->name ) )
-    {
-        error( 10, {}, zObj );
-        return 0;
-    }
-    KSGSCompileKlasse *k = zKT->get( (char *)zLK->name );
-    int lFAnz = zLK->funktionen.getEintragAnzahl();
-    for( int i = 0; i < lFAnz; i++ )
-    {
-        if( !compileFunktion( zLK->funktionen.get( i ), zKT, &k->funcs, 1 + !zLK->fSichtbar.get( i ) ) )
-            return 0;
-    }
-    k->vars.addVariable( "this", new KSGSCompileVariable( k->id, 2 ) );
-    int lVAnz = zLK->variablen.getEintragAnzahl();
-    for( int i = 0; i < lVAnz; i++ )
-    {
-        auto tmp = zKT->get( (char *)zLK->variablen.get( i )->typ );
-        if( !tmp )
-        {
-            error( 11, { zLK->debug.datei, Text() += zLK->debug.zeile, (char *)zLK->variablen.get( i )->typ, (char *)zLK->variablen.get( i )->name }, zObj );
-            return 0;
-        }
-        if( !k->vars.addVariable( zLK->variablen.get( i )->name, new KSGSCompileVariable( tmp->id, 1 + !zLK->vSichtbar.get( i ) ) ) )
-        {
-            error( 9, { zLK->variablen.get( i )->debug.datei, Text() += zLK->variablen.get( i )->debug.zeile, zLK->variablen.get( i )->name }, zObj );
-            return 0;
-        }
-    }
-    return 1;
+	if (!zKT->hat(zLK->name))
+	{
+		error(10, {}, zObj);
+		return 0;
+	}
+	KSGSCompileKlasse* k = zKT->get(zLK->name);
+	int lFAnz = zLK->funktionen.getEintragAnzahl();
+	for (int i = 0; i < lFAnz; i++)
+	{
+		if (!compileFunktion(zLK->funktionen.get(i), zKT, &k->funcs, 1 + !zLK->fSichtbar.get(i)))
+			return 0;
+	}
+	k->vars.addVariable("this", new KSGSCompileVariable(k->id, 2));
+	int lVAnz = zLK->variablen.getEintragAnzahl();
+	for (int i = 0; i < lVAnz; i++)
+	{
+		auto tmp = zKT->get(zLK->variablen.get(i)->typ);
+		if (!tmp)
+		{
+			error(11, { zLK->debug.datei, Text() += zLK->debug.zeile, zLK->variablen.get(i)->typ, zLK->variablen.get(i)->name }, zObj);
+			return 0;
+		}
+		if (!k->vars.addVariable(zLK->variablen.get(i)->name, new KSGSCompileVariable(tmp->id, 1 + !zLK->vSichtbar.get(i))))
+		{
+			error(9, { zLK->variablen.get(i)->debug.datei, Text() += zLK->variablen.get(i)->debug.zeile, zLK->variablen.get(i)->name }, zObj);
+			return 0;
+		}
+	}
+	return 1;
 }
 
-bool KSGSLeser::compileFunktion( KSGSLeseFunktion *zLF, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, int s )
+bool KSGSLeser::compileFunktion(KSGSLeseFunktion* zLF, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, int s)
 {
-    KSGSCompileFunktion *f = new KSGSCompileFunktion( zKT->get( (char *)zLF->typ )->id, s, {} );
-    int anz = zLF->parameter.getEintragAnzahl();
-    for( int j = 0; j < anz; j++ )
-    {
-        auto tmp = zKT->get( (char *)zLF->parameter.get( j )->typ );
-        if( tmp )
-            f->parameterTyp.add( tmp->id );
-        else
-        {
-            error( 11, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->parameter.get( j )->typ, zLF->parameter.get( j )->name }, zObj );
-            return 0;
-        }
-    }
-    if( !zFT->addFunktion( zLF->name, f ) )
-    {
-        error( 8, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->name }, zObj );
-        return 0;
-    }
-    return 1;
+	KSGSCompileFunktion* f = new KSGSCompileFunktion(zKT->get(zLF->typ)->id, s, {});
+	int anz = zLF->parameter.getEintragAnzahl();
+	for (int j = 0; j < anz; j++)
+	{
+		auto tmp = zKT->get(zLF->parameter.get(j)->typ);
+		if (tmp)
+			f->parameterTyp.add(tmp->id);
+		else
+		{
+			error(11, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->parameter.get(j)->typ, zLF->parameter.get(j)->name }, zObj);
+			return 0;
+		}
+	}
+	if (!zFT->addFunktion(zLF->name, f))
+	{
+		error(8, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->name }, zObj);
+		return 0;
+	}
+	return 1;
 }
 
-KSGSVariableDef *KSGSLeser::compileVariable( KSGSLeseVariable *zLV, KSGSCompKlassTable *zKT, int id )
+KSGSVariableDef* KSGSLeser::compileVariable(KSGSLeseVariable* zLV, KSGSCompKlassTable* zKT, int id)
 {
-    if( !zKT->hat( (char *)zLV->typ ) )
-    {
-        error( 11, { zLV->debug.datei, Text() += zLV->debug.zeile, zLV->typ, zLV->name }, zObj );
-        return 0;
-    }
-    KSGSVariableDef *ret = new KSGSVariableDef();
-    ret->id = id;
-    ret->sichtbar = 0;
-    ret->typId = zKT->get( (char *)zLV->typ )->id;
-    ret->wert.setText( zLV->wert );
-    return ret;
+	if (!zKT->hat(zLV->typ))
+	{
+		error(11, { zLV->debug.datei, Text() += zLV->debug.zeile, zLV->typ, zLV->name }, zObj);
+		return 0;
+	}
+	KSGSVariableDef* ret = new KSGSVariableDef();
+	ret->id = id;
+	ret->sichtbar = 0;
+	ret->typId = zKT->get(zLV->typ)->id;
+	ret->wert.setText(zLV->wert);
+	return ret;
 }
 
-KSGSKlasse *KSGSLeser::buildKlasse( KSGSLeseKlasse *zLK, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT )
+KSGSKlasse* KSGSLeser::buildKlasse(KSGSLeseKlasse* zLK, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT)
 {
-    if( !zKT->hat( (char *)zLK->name ) )
-    {
-        error( 10, {}, zObj );
-        return 0;
-    }
-    KSGSKlasse *ret = new KSGSKlasse( zKT->get( (char *)zLK->name )->id );
-    int anz = zLK->funktionen.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        KSGSFunktion *f = buildFunktion( zLK->funktionen.get( i ), zKT, zFT, zVT, zLK->name );
-        if( !f )
-        {
-            ret->release();
-            return 0;
-        }
-        ret->addFunktion( f );
-    }
-    anz = zLK->variablen.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        KSGSVariableDef *v = compileVariable( zLK->variablen.get( i ), zKT, i );
-        if( !v )
-        {
-            ret->release();
-            return 0;
-        }
-        v->sichtbar = 1 + !zLK->vSichtbar.get( i );
-        ret->addVariable( v );
-    }
-    return ret;
+	if (!zKT->hat(zLK->name))
+	{
+		error(10, {}, zObj);
+		return 0;
+	}
+	KSGSKlasse* ret = new KSGSKlasse(zKT->get(zLK->name)->id);
+	int anz = zLK->funktionen.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		KSGSFunktion* f = buildFunktion(zLK->funktionen.get(i), zKT, zFT, zVT, zLK->name);
+		if (!f)
+		{
+			ret->release();
+			return 0;
+		}
+		ret->addFunktion(f);
+	}
+	anz = zLK->variablen.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		KSGSVariableDef* v = compileVariable(zLK->variablen.get(i), zKT, i);
+		if (!v)
+		{
+			ret->release();
+			return 0;
+		}
+		v->sichtbar = 1 + !zLK->vSichtbar.get(i);
+		ret->addVariable(v);
+	}
+	return ret;
 }
 
-KSGSFunktion *KSGSLeser::buildFunktion( KSGSLeseFunktion *zLF, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT, const char *klassName )
+KSGSFunktion* KSGSLeser::buildFunktion(KSGSLeseFunktion* zLF, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT, const char* klassName)
 {
-    KSGSCompFuncTable *ft = zFT;
-    if( klassName )
-        ft = &zKT->get( klassName )->funcs;
-    if( !ft->hat( zLF->name ) )
-    {
-        error( 10, {}, zObj );
-        return 0;
-    }
-    KSGSFunktion *ret = new KSGSFunktion( ft->get( zLF->name )->id, ft->get( zLF->name )->sichtbar, zKT->get( (char *)zLF->typ )->id );
-    ret->setName( zLF->name );
-    int anz = zLF->parameter.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        KSGSVariableDef *v = compileVariable( zLF->parameter.get( i ), zKT, i );
-        if( !v )
-        {
-            ret->release();
-            return 0;
-        }
-        v->sichtbar = 3;
-        ret->addParameter( v );
-        auto tmp = zKT->get( (char *)zLF->parameter.get( i )->typ );
-        if( !tmp )
-        {
-            error( 11, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->parameter.get( i )->typ, zLF->parameter.get( i )->name }, zObj );
-            return 0;
-        }
-        ft->get( zLF->name )->vars.addVariable( zLF->parameter.get( i )->name, new KSGSCompileVariable( tmp->id, 3 ) );
-    }
-    anz = zLF->befehle.getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        KSGSBefehl *b = buildBefehl( zLF->befehle.get( i ), zKT, zFT, zVT, klassName, zLF->name );
-        if( !b )
-        {
-            ret->release();
-            return 0;
-        }
-        ret->addBefehl( b );
-    }
-    return ret;
+	KSGSCompFuncTable* ft = zFT;
+	if (klassName)
+		ft = &zKT->get(klassName)->funcs;
+	if (!ft->hat(zLF->name))
+	{
+		error(10, {}, zObj);
+		return 0;
+	}
+	KSGSFunktion* ret = new KSGSFunktion(ft->get(zLF->name)->id, ft->get(zLF->name)->sichtbar, zKT->get(zLF->typ)->id);
+	ret->setName(zLF->name);
+	int anz = zLF->parameter.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		KSGSVariableDef* v = compileVariable(zLF->parameter.get(i), zKT, i);
+		if (!v)
+		{
+			ret->release();
+			return 0;
+		}
+		v->sichtbar = 3;
+		ret->addParameter(v);
+		auto tmp = zKT->get(zLF->parameter.get(i)->typ);
+		if (!tmp)
+		{
+			error(11, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->parameter.get(i)->typ, zLF->parameter.get(i)->name }, zObj);
+			return 0;
+		}
+		ft->get(zLF->name)->vars.addVariable(zLF->parameter.get(i)->name, new KSGSCompileVariable(tmp->id, 3));
+	}
+	anz = zLF->befehle.getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		KSGSBefehl* b = buildBefehl(zLF->befehle.get(i), zKT, zFT, zVT, klassName, zLF->name);
+		if (!b)
+		{
+			ret->release();
+			return 0;
+		}
+		ret->addBefehl(b);
+	}
+	return ret;
 }
 
-KSGSBefehl *KSGSLeser::buildBefehl( KSGSLeseBefehl *zLB, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
+KSGSBefehl* KSGSLeser::buildBefehl(KSGSLeseBefehl* zLB, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
 {
-    KSGSBefehl *ret = 0;
-    zLB->befehl.setSuchGrenzen( '(', ')' );
-    removeKlammer( &zLB->befehl );
-    switch( zLB->typ )
-    {
-    case 0: // call oder operator
-        if( 1 )
-        {
-            if( hatOperator( &zLB->befehl ) >= 0 )
-                ret = new KSGSOperatorBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-            else
-                ret = new KSGSCallBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-        }
-        break;
-    case 3: // var
-        ret = new KSGSVariableBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    case 6: // if
-        ret = new KSGSIfBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    case 7: // for
-        ret = new KSGSForBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    case 8: // while
-        ret = new KSGSWhileBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    case 9: // return
-        ret = new KSGSReturnBefehl( zObj, zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    case 10: // break
-        ret = new KSGSBreakBefehl( zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    case 11: // continue
-        ret = new KSGSContinueBefehl( zLB, zKT, zFT, zVT, klassName, funktionName );
-        break;
-    }
-    if( !ret )
-        error( 13, { zLB->debug.datei, Text() += zLB->debug.zeile, zLB->befehl }, zObj );
-    if( ret && ret->hatFehler() )
-        ret = (KSGSBefehl *)ret->release();
-    return ret;
+	KSGSBefehl* ret = 0;
+	zLB->befehl.setSuchGrenzen('(', ')');
+	removeKlammer(&zLB->befehl);
+	switch (zLB->typ)
+	{
+	case 0: // call oder operator
+		if (1)
+		{
+			if (hatOperator(&zLB->befehl) >= 0)
+				ret = new KSGSOperatorBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+			else
+				ret = new KSGSCallBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+		}
+		break;
+	case 3: // var
+		ret = new KSGSVariableBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	case 6: // if
+		ret = new KSGSIfBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	case 7: // for
+		ret = new KSGSForBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	case 8: // while
+		ret = new KSGSWhileBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	case 9: // return
+		ret = new KSGSReturnBefehl(zObj, zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	case 10: // break
+		ret = new KSGSBreakBefehl(zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	case 11: // continue
+		ret = new KSGSContinueBefehl(zLB, zKT, zFT, zVT, klassName, funktionName);
+		break;
+	}
+	if (!ret)
+		error(13, { zLB->debug.datei, Text() += zLB->debug.zeile, zLB->befehl }, zObj);
+	if (ret && ret->hatFehler())
+		ret = (KSGSBefehl*)ret->release();
+	return ret;
 }
 
 // nicht constant
 bool KSGSLeser::laden()
 {
-    delete dat;
-    dat = new KSGSLeseScript();
-    bool ok = ladeDatei();
-    return ok;
+	delete dat;
+	dat = new KSGSLeseScript();
+	bool ok = ladeDatei();
+	return ok;
 }
 
-bool KSGSLeser::compile( RCArray< KSGSKlasse > *klassen, RCArray< KSGSFunktion > *funktionen, Array< KSGSVariableDef * > *variablen )
+bool KSGSLeser::compile(RCArray< KSGSKlasse >* klassen, RCArray< KSGSFunktion >* funktionen, Array< KSGSVariableDef* >* variablen)
 {
-    // Klassen Tabelle
-    KSGSCompKlassTable *klassT = new KSGSCompKlassTable();
-    int kAnz = dat->klassen.getEintragAnzahl();
-    for( int i = 0; i < kAnz; i++ )
-    {
-        if( !klassT->addKlasse( dat->klassen.get( i )->name, new KSGSCompileKlasse() ) )
-        {
-            error( 7, { dat->klassen.get( i )->debug.datei, Text() += dat->klassen.get( i )->debug.zeile, dat->klassen.get( i )->name }, zObj );
-            klassT->release();
-            return 0;
-        }
-    }
-    // Funktions Tabelle
-    KSGSCompFuncTable *funcT = new KSGSCompFuncTable();
-    funcT->addFunktion( "Rückruf", new KSGSCompileFunktion( KSGS_VOID, 0, {} ) );
-    int fAnz = dat->funktionen.getEintragAnzahl();
-    for( int i = 0; i < fAnz; i++ )
-    {
-        if( !compileFunktion( dat->funktionen.get( i ), klassT, funcT ) )
-        {
-            error( 8, { dat->funktionen.get( i )->debug.datei, Text() += dat->funktionen.get( i )->debug.zeile, dat->funktionen.get( i )->name }, zObj );
-            klassT->release();
-            funcT->release();
-            return 0;
-        }
-        if( dat->funktionen.get( i )->name.istGleich( "start" ) )
-            mainFuncId = funcT->get( "start" )->id;
-        if( dat->funktionen.get( i )->name.istGleich( "maus" ) )
-            mausFuncId = funcT->get( "maus" )->id;
-        if( dat->funktionen.get( i )->name.istGleich( "tastatur" ) )
-            tastaturFuncId = funcT->get( "tastatur" )->id;
-        if( dat->funktionen.get( i )->name.istGleich( "tick" ) )
-            tickFuncId = funcT->get( "tick" )->id;
-        if( dat->funktionen.get( i )->name.istGleich( "render" ) )
-            renderFuncId = funcT->get( "render" )->id;
-    }
-    // Variablen Tabelle
-    KSGSCompVarTable *varT = new KSGSCompVarTable();
-    int vAnz = dat->variablen.getEintragAnzahl();
-    for( int i = 0; i < vAnz; i++ )
-    {
-        auto tmp = klassT->get( (char *)dat->variablen.get( i )->typ );
-        if( !tmp )
-        {
-            error( 11, { dat->variablen.get( i )->debug.datei, Text() += dat->variablen.get( i )->debug.zeile, dat->variablen.get( i )->typ, dat->variablen.get( i )->name }, zObj );
-            return 0;
-        }
-        if( !varT->addVariable( dat->variablen.get( i )->name, new KSGSCompileVariable( klassT->get( (char *)dat->variablen.get( i )->typ )->id, 0 ) ) )
-        {
-            error( 9, { dat->variablen.get( i )->debug.datei, Text() += dat->variablen.get( i )->debug.zeile, dat->variablen.get( i )->name }, zObj );
-            klassT->release();
-            funcT->release();
-            varT->release();
-            return 0;
-        }
-    }
-    for( int i = 0; i < kAnz; i++ )
-    {
-        if( !compileKlasse( dat->klassen.get( i ), klassT ) )
-        {
-            klassT->release();
-            funcT->release();
-            varT->release();
-            return 0;
-        }
-    }
-    for( int i = 0; i < vAnz; i++ )
-    {
-        KSGSVariableDef *k = compileVariable( dat->variablen.get( i ), klassT, i );
-        if( !k )
-        {
-            int anz = variablen->getEintragAnzahl();
-            for( int i = 0; i < anz; i++ )
-                delete variablen->get( i );
-            variablen->leeren();
-            klassT->release();
-            funcT->release();
-            varT->release();
-            return 0;
-        }
-        variablen->add( k );
-    }
-    for( int i = 0; i < kAnz; i++ )
-    {
-        KSGSKlasse *k = buildKlasse( dat->klassen.get( i ), klassT, funcT, varT );
-        if( !k )
-        {
-            klassen->leeren();
-            variablen->leeren();
-            klassT->release();
-            funcT->release();
-            varT->release();
-            return 0;
-        }
-        klassen->add( k );
-    }
-    funktionen->add( new KSGSCallbackFunktion() );
-    for( int i = 0; i < fAnz; i++ )
-    {
-        KSGSFunktion *f = buildFunktion( dat->funktionen.get( i ), klassT, funcT, varT );
-        if( !f )
-        {
-            klassen->leeren();
-            funktionen->leeren();
-            variablen->leeren();
-            klassT->release();
-            funcT->release();
-            varT->release();
-            return 0;
-        }
-        funktionen->add( f );
-    }
-    klassT->release();
-    funcT->release();
-    varT->release();
-    return 1;
+	// Klassen Tabelle
+	KSGSCompKlassTable* klassT = new KSGSCompKlassTable();
+	int kAnz = dat->klassen.getEintragAnzahl();
+	for (int i = 0; i < kAnz; i++)
+	{
+		if (!klassT->addKlasse(dat->klassen.get(i)->name, new KSGSCompileKlasse()))
+		{
+			error(7, { dat->klassen.get(i)->debug.datei, Text() += dat->klassen.get(i)->debug.zeile, dat->klassen.get(i)->name }, zObj);
+			klassT->release();
+			return 0;
+		}
+	}
+	// Funktions Tabelle
+	KSGSCompFuncTable* funcT = new KSGSCompFuncTable();
+	funcT->addFunktion("Rückruf", new KSGSCompileFunktion(KSGS_VOID, 0, {}));
+	int fAnz = dat->funktionen.getEintragAnzahl();
+	for (int i = 0; i < fAnz; i++)
+	{
+		if (!compileFunktion(dat->funktionen.get(i), klassT, funcT))
+		{
+			error(8, { dat->funktionen.get(i)->debug.datei, Text() += dat->funktionen.get(i)->debug.zeile, dat->funktionen.get(i)->name }, zObj);
+			klassT->release();
+			funcT->release();
+			return 0;
+		}
+		if (dat->funktionen.get(i)->name.istGleich("start"))
+			mainFuncId = funcT->get("start")->id;
+		if (dat->funktionen.get(i)->name.istGleich("maus"))
+			mausFuncId = funcT->get("maus")->id;
+		if (dat->funktionen.get(i)->name.istGleich("tastatur"))
+			tastaturFuncId = funcT->get("tastatur")->id;
+		if (dat->funktionen.get(i)->name.istGleich("tick"))
+			tickFuncId = funcT->get("tick")->id;
+		if (dat->funktionen.get(i)->name.istGleich("render"))
+			renderFuncId = funcT->get("render")->id;
+	}
+	// Variablen Tabelle
+	KSGSCompVarTable* varT = new KSGSCompVarTable();
+	int vAnz = dat->variablen.getEintragAnzahl();
+	for (int i = 0; i < vAnz; i++)
+	{
+		auto tmp = klassT->get(dat->variablen.get(i)->typ);
+		if (!tmp)
+		{
+			error(11, { dat->variablen.get(i)->debug.datei, Text() += dat->variablen.get(i)->debug.zeile, dat->variablen.get(i)->typ, dat->variablen.get(i)->name }, zObj);
+			return 0;
+		}
+		if (!varT->addVariable(dat->variablen.get(i)->name, new KSGSCompileVariable(klassT->get(dat->variablen.get(i)->typ)->id, 0)))
+		{
+			error(9, { dat->variablen.get(i)->debug.datei, Text() += dat->variablen.get(i)->debug.zeile, dat->variablen.get(i)->name }, zObj);
+			klassT->release();
+			funcT->release();
+			varT->release();
+			return 0;
+		}
+	}
+	for (int i = 0; i < kAnz; i++)
+	{
+		if (!compileKlasse(dat->klassen.get(i), klassT))
+		{
+			klassT->release();
+			funcT->release();
+			varT->release();
+			return 0;
+		}
+	}
+	for (int i = 0; i < vAnz; i++)
+	{
+		KSGSVariableDef* k = compileVariable(dat->variablen.get(i), klassT, i);
+		if (!k)
+		{
+			int anz = variablen->getEintragAnzahl();
+			for (int i = 0; i < anz; i++)
+				delete variablen->get(i);
+			variablen->leeren();
+			klassT->release();
+			funcT->release();
+			varT->release();
+			return 0;
+		}
+		variablen->add(k);
+	}
+	for (int i = 0; i < kAnz; i++)
+	{
+		KSGSKlasse* k = buildKlasse(dat->klassen.get(i), klassT, funcT, varT);
+		if (!k)
+		{
+			klassen->leeren();
+			variablen->leeren();
+			klassT->release();
+			funcT->release();
+			varT->release();
+			return 0;
+		}
+		klassen->add(k);
+	}
+	funktionen->add(new KSGSCallbackFunktion());
+	for (int i = 0; i < fAnz; i++)
+	{
+		KSGSFunktion* f = buildFunktion(dat->funktionen.get(i), klassT, funcT, varT);
+		if (!f)
+		{
+			klassen->leeren();
+			funktionen->leeren();
+			variablen->leeren();
+			klassT->release();
+			funcT->release();
+			varT->release();
+			return 0;
+		}
+		funktionen->add(f);
+	}
+	klassT->release();
+	funcT->release();
+	varT->release();
+	return 1;
 }
 
 // constant
 int KSGSLeser::getMainFuncId() const
 {
-    return mainFuncId;
+	return mainFuncId;
 }
 
 int KSGSLeser::getMausFuncId() const
 {
-    return mausFuncId;
+	return mausFuncId;
 }
 
 int KSGSLeser::getTastaturFuncId() const
 {
-    return tastaturFuncId;
+	return tastaturFuncId;
 }
 
 int KSGSLeser::getTickFuncId() const
 {
-    return tickFuncId;
+	return tickFuncId;
 }
 
 int KSGSLeser::getRenderFuncId() const
 {
-    return renderFuncId;
+	return renderFuncId;
 }

ksgScript/Main/KSGSExpressionEvaluator.cpp

@@ -7,237 +7,237 @@
 using namespace KSGScript;
 
 KSGSExpressionEvaluatorImpl::KSGSExpressionEvaluatorImpl()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    functions = new RCArray< KSGSFunktion >();
-    classes = new RCArray< KSGSKlasse >();
-    params = new Framework::RCArray<KSGSVariable>();
-    variables = new RCArray< KSGSVariable >();
-    expression = "";
+	functions = new RCArray< KSGSFunktion >();
+	classes = new RCArray< KSGSKlasse >();
+	params = new Framework::RCArray<KSGSVariable>();
+	variables = new RCArray< KSGSVariable >();
+	expression = "";
 }
 
 KSGSExpressionEvaluatorImpl::~KSGSExpressionEvaluatorImpl()
 {
-    params->release();
-    functions->release();
-    classes->release();
-    variables->release();
+	params->release();
+	functions->release();
+	classes->release();
+	variables->release();
 }
 
 void KSGSExpressionEvaluatorImpl::compile()
 {
-    functions->leeren();
-    classes->leeren();
-    variables->leeren();
-    Framework::Text script = "func double start(";
-    Iterator<Text*> name = paramNames->begin();
-    for( Iterator<KSGSVariable*> it = params->begin(); it && name; it = it.next(), name = name.next() )
-    {
-        switch( it->getTyp() )
-        {
-        case KSGS_BOOL:
-            script += "bool " + name;
-            break;
-        case KSGS_INT:
-            script += "int " + name;
-            break;
-        case KSGS_DOUBLE:
-            script += "double " + name;
-            break;
-        case KSGS_ARRAY:
-            script += "Array " + name;
-            break;
-        case KSGS_THREAD:
-            script += "Thread " + name;
-            break;
-        case KSGS_TEXT:
-            script += "Text " + name;
-            break;
-        case KSGS_BILD:
-            script += "Bild " + name;
-            break;
-        case KSGS_MAUSEREIGNIS:
-            script += "MausEreignis " + name;
-            break;
-        case KSGS_TASTATUREREIGNIS:
-            script += "TastaturEreignis " + name;
-            break;
-        case KSGS_TEXTFELD:
-            script += "TextFeld " + name;
-            break;
-        case KSGS_KNOPF:
-            script += "Knopf " + name;
-            break;
-        case KSGS_FENSTER:
-            script += "Fenster " + name;
-            break;
-        case KSGS_BILDO:
-            script += "BildZ " + name;
-            break;
-        case KSGS_ANIMATION2DDATA:
-            script += "Animation2DData " + name;
-            break;
-        case KSGS_ANIMATION2D:
-            script += "Animation2D " + name;
-            break;
-        }
-        if( it.hasNext() )
-            script += ", ";
-    }
-    script += Text( ") { return " ) + expression + Text( "; }" );
-    TextReader* expressionReader = new TextReader( new Text( script ) );
-    KSGSLeser* reader = new KSGSLeser( expressionReader, this, "expression" );
-    if( !reader->laden() )
-    {
-        expressionReader->release();
-        return;
-    }
-    Array< KSGSVariableDef* >* varDefs = new Array< KSGSVariableDef* >();
-    if( !reader->compile( classes, functions, varDefs ) )
-    {
-        varDefs->release();
-        expressionReader->release();
-        return;
-    }
-    reader->release();
-    int vAnz = varDefs->getEintragAnzahl();
-    for( int i = 0; i < vAnz; i++ )
-    {
-        KSGSVariable* var = KSGSKlasseInstanz::erstellVariable( this, varDefs->get( i ) );
-        if( var )
-            variables->add( var );
-        delete varDefs->get( i );
-    }
-    varDefs->release();
-    expressionReader->release();
-
-}
-
-KSGSVariable* KSGSExpressionEvaluatorImpl::createParameter( Framework::Text name, int type )
-{
-    this->paramNames->add( new Text( name ) );
-    KSGSVariable* var = KSGSKlasseInstanz::erstellVariable( this, new KSGSVariableDef{ type, 0, 0, "" } );
-    this->params->add( dynamic_cast<KSGSVariable*>(var->getThis()) );
-    if( this->expression.getLength() > 0 )
-        compile();
-    return var;
-}
-
-KSGSVariable* KSGSExpressionEvaluatorImpl::getParameter( Framework::Text name )
-{
-    int vAnz = paramNames->getEintragAnzahl();
-    for( int i = 0; i < vAnz; i++ )
-    {
-        if( paramNames->z( i )->istGleich( name ) )
-            return params->get( i );
-    }
-    return 0;
-}
-
-void KSGSExpressionEvaluatorImpl::setExpression( Framework::Text expression )
-{
-    this->expression = expression;
-    compile();
+	functions->leeren();
+	classes->leeren();
+	variables->leeren();
+	Framework::Text script = "func double start(";
+	Iterator<Text*> name = paramNames->begin();
+	for (Iterator<KSGSVariable*> it = params->begin(); it && name; it = it.next(), name = name.next())
+	{
+		switch (it->getTyp())
+		{
+		case KSGS_BOOL:
+			script += "bool " + name;
+			break;
+		case KSGS_INT:
+			script += "int " + name;
+			break;
+		case KSGS_DOUBLE:
+			script += "double " + name;
+			break;
+		case KSGS_ARRAY:
+			script += "Array " + name;
+			break;
+		case KSGS_THREAD:
+			script += "Thread " + name;
+			break;
+		case KSGS_TEXT:
+			script += "Text " + name;
+			break;
+		case KSGS_BILD:
+			script += "Bild " + name;
+			break;
+		case KSGS_MAUSEREIGNIS:
+			script += "MausEreignis " + name;
+			break;
+		case KSGS_TASTATUREREIGNIS:
+			script += "TastaturEreignis " + name;
+			break;
+		case KSGS_TEXTFELD:
+			script += "TextFeld " + name;
+			break;
+		case KSGS_KNOPF:
+			script += "Knopf " + name;
+			break;
+		case KSGS_FENSTER:
+			script += "Fenster " + name;
+			break;
+		case KSGS_BILDO:
+			script += "BildZ " + name;
+			break;
+		case KSGS_ANIMATION2DDATA:
+			script += "Animation2DData " + name;
+			break;
+		case KSGS_ANIMATION2D:
+			script += "Animation2D " + name;
+			break;
+		}
+		if (it.hasNext())
+			script += ", ";
+	}
+	script += Text(") { return ") + expression + Text("; }");
+	TextReader* expressionReader = new TextReader(new Text(script));
+	KSGSLeser* reader = new KSGSLeser(expressionReader, this, "expression");
+	if (!reader->laden())
+	{
+		expressionReader->release();
+		return;
+	}
+	Array< KSGSVariableDef* >* varDefs = new Array< KSGSVariableDef* >();
+	if (!reader->compile(classes, functions, varDefs))
+	{
+		varDefs->release();
+		expressionReader->release();
+		return;
+	}
+	reader->release();
+	int vAnz = varDefs->getEintragAnzahl();
+	for (int i = 0; i < vAnz; i++)
+	{
+		KSGSVariable* var = KSGSKlasseInstanz::erstellVariable(this, varDefs->get(i));
+		if (var)
+			variables->add(var);
+		delete varDefs->get(i);
+	}
+	varDefs->release();
+	expressionReader->release();
+
+}
+
+KSGSVariable* KSGSExpressionEvaluatorImpl::createParameter(Framework::Text name, int type)
+{
+	this->paramNames->add(new Text(name));
+	KSGSVariable* var = KSGSKlasseInstanz::erstellVariable(this, new KSGSVariableDef{ type, 0, 0, "" });
+	this->params->add(dynamic_cast<KSGSVariable*>(var->getThis()));
+	if (this->expression.getLength() > 0)
+		compile();
+	return var;
+}
+
+KSGSVariable* KSGSExpressionEvaluatorImpl::getParameter(Framework::Text name)
+{
+	int vAnz = paramNames->getEintragAnzahl();
+	for (int i = 0; i < vAnz; i++)
+	{
+		if (paramNames->z(i)->istGleich(name))
+			return params->get(i);
+	}
+	return 0;
+}
+
+void KSGSExpressionEvaluatorImpl::setExpression(Framework::Text expression)
+{
+	this->expression = expression;
+	compile();
 }
 
 KSGSVariable* KSGSExpressionEvaluatorImpl::evaluate()
 {
-    if( functions->getEintragAnzahl() > 0 )
-        return startFunktion( functions->z( 0 )->getId(), dynamic_cast<RCArray<KSGSVariable>*>(params->getThis()) );
-    return 0;
+	if (functions->getEintragAnzahl() > 0)
+		return startFunktion(functions->z(0)->getId(), dynamic_cast<RCArray<KSGSVariable>*>(params->getThis()));
+	return 0;
 }
 
-void KSGSExpressionEvaluatorImpl::logNachricht( char* n )
+void KSGSExpressionEvaluatorImpl::logNachricht(const char* n)
 {
-    std::cout << n << "\n";
+	std::cout << n << "\n";
 }
 
-Framework::Text* KSGSExpressionEvaluatorImpl::convertPfad( char* pf )
+Framework::Text* KSGSExpressionEvaluatorImpl::convertPfad(const char* pf)
 {
-    Text* ret = new Text( pf );
-    ret->ersetzen( '\\', '/' );
-    if( ret->getText()[ 0 ] == '/' )
-    {
-        ret->remove( 0 );
-        return ret;
-    }
-    return ret;
+	Text* ret = new Text(pf);
+	ret->ersetzen('\\', '/');
+	if (ret->getText()[0] == '/')
+	{
+		ret->remove(0);
+		return ret;
+	}
+	return ret;
 }
 
-void KSGSExpressionEvaluatorImpl::setVariable( int id, KSGSVariable* var )
+void KSGSExpressionEvaluatorImpl::setVariable(int id, KSGSVariable* var)
 {
-    variables->set( var, id );
+	variables->set(var, id);
 }
 
-KSGSVariable* KSGSExpressionEvaluatorImpl::startFunktion( int id, Framework::RCArray< KSGSVariable >* parameter )
+KSGSVariable* KSGSExpressionEvaluatorImpl::startFunktion(int id, Framework::RCArray< KSGSVariable >* parameter)
 {
-    if( !functions->z( id ) || functions->z( id )->getSichtbarkeit() != 0 )
-    {
-        error( 19, {}, this );
-        parameter->release();
-        return 0;
-    }
-    KSGSFunktionInstanz* inst = functions->z( id )->erstellInstanz( dynamic_cast<KSGScriptProcessor*>(getThis()), 0, parameter );
-    KSGSVariable* ret = inst->startFunktion();
-    inst->release();
-    return ret;
+	if (!functions->z(id) || functions->z(id)->getSichtbarkeit() != 0)
+	{
+		error(19, {}, this);
+		parameter->release();
+		return 0;
+	}
+	KSGSFunktionInstanz* inst = functions->z(id)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, parameter);
+	KSGSVariable* ret = inst->startFunktion();
+	inst->release();
+	return ret;
 }
 
-KSGSVariable* KSGSExpressionEvaluatorImpl::erstellKlassenInstanz( int id )
+KSGSVariable* KSGSExpressionEvaluatorImpl::erstellKlassenInstanz(int id)
 {
-    int anz = classes->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( classes->z( i ) && classes->z( i )->getId() == id )
-            return classes->z( i )->erstellInstanz( this );
-    }
-    error( 2, {}, this );
-    return 0;
+	int anz = classes->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (classes->z(i) && classes->z(i)->getId() == id)
+			return classes->z(i)->erstellInstanz(this);
+	}
+	error(2, {}, this);
+	return 0;
 }
 
-KSGSVariable* KSGSExpressionEvaluatorImpl::getVariable( int id ) const
+KSGSVariable* KSGSExpressionEvaluatorImpl::getVariable(int id) const
 {
-    if( !variables || !variables->z( id ) )
-    {
-        error( 17, {}, (KSGScriptProcessor*)this );
-        return 0;
-    }
-    return variables->get( id );
+	if (!variables || !variables->z(id))
+	{
+		error(17, {}, (KSGScriptProcessor*)this);
+		return 0;
+	}
+	return variables->get(id);
 }
 
 int KSGSExpressionEvaluatorImpl::getScriptId() const
 {
-    return 0;
+	return 0;
 }
 
 Framework::Bildschirm* KSGSExpressionEvaluatorImpl::zBildschirm() const
 {
-    return 0;
+	return 0;
 }
 
 Framework::Schrift* KSGSExpressionEvaluatorImpl::zSchrift() const
 {
-    return 0;
+	return 0;
 }
 
-int KSGSExpressionEvaluatorImpl::getFunktionId( const char* name ) const
+int KSGSExpressionEvaluatorImpl::getFunktionId(const char* name) const
 {
-    int anz = functions->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( functions->z( i )->hatName( name ) )
-            return i;
-    }
-    return -1;
+	int anz = functions->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (functions->z(i)->hatName(name))
+			return i;
+	}
+	return -1;
 }
 
-bool KSGSExpressionEvaluatorImpl::istBeendet( int scrId ) const
+bool KSGSExpressionEvaluatorImpl::istBeendet(int scrId) const
 {
-    return false;
+	return false;
 }
 
-KSGSVariable* KSGSExpressionEvaluatorImpl::callback( Framework::RCArray< KSGSVariable >* parameter ) const
+KSGSVariable* KSGSExpressionEvaluatorImpl::callback(Framework::RCArray< KSGSVariable >* parameter) const
 {
-    parameter->release();
-    return 0;
+	parameter->release();
+	return 0;
 }

ksgScript/Main/KSGSExpressionEvaluator.h

@@ -6,42 +6,42 @@
 namespace KSGScript
 {
 
-    class KSGSKlasse;
-    class KSGSVariable;
-    class KSGSFunktion;
+	class KSGSKlasse;
+	class KSGSVariable;
+	class KSGSFunktion;
 
-    class KSGSExpressionEvaluatorImpl : public KSGSExpressionEvaluator
-    {
-    private:
-        Framework::RCArray<KSGSVariable> *params;
-        Framework::RCArray<Text> *paramNames;
-        Framework::Text expression;
-        RCArray< KSGSFunktion > *functions;
-        RCArray< KSGSKlasse > *classes;
-        RCArray< KSGSVariable > *variables;
+	class KSGSExpressionEvaluatorImpl : public KSGSExpressionEvaluator
+	{
+	private:
+		Framework::RCArray<KSGSVariable>* params;
+		Framework::RCArray<Text>* paramNames;
+		Framework::Text expression;
+		RCArray< KSGSFunktion >* functions;
+		RCArray< KSGSKlasse >* classes;
+		RCArray< KSGSVariable >* variables;
 
-    private:
-        void compile();
+	private:
+		void compile();
 
-    public:
-        KSGSExpressionEvaluatorImpl();
-        ~KSGSExpressionEvaluatorImpl();
+	public:
+		KSGSExpressionEvaluatorImpl();
+		~KSGSExpressionEvaluatorImpl();
 
-        KSGSVariable *createParameter( Framework::Text name, int type ) override;
-        KSGSVariable *getParameter( Framework::Text name ) override;
-        void setExpression( Framework::Text expression ) override;
-        KSGSVariable *evaluate() override;
-        void logNachricht( char *n ) override;
-        Framework::Text *convertPfad( char *pf ) override;
-        void setVariable( int id, KSGSVariable *var ) override;
-        KSGSVariable *startFunktion( int id, Framework::RCArray< KSGSVariable > *parameter ) override;
-        KSGSVariable *erstellKlassenInstanz( int id ) override;
-        KSGSVariable *getVariable( int id ) const override;
-        int getScriptId() const override;
-        Framework::Bildschirm *zBildschirm() const override;
-        Framework::Schrift *zSchrift() const override;
-        int getFunktionId( const char *name ) const override;
-        bool istBeendet( int scrId ) const override;
-        KSGSVariable *callback( Framework::RCArray< KSGSVariable > *parameter ) const override;
-    };
+		KSGSVariable* createParameter(Framework::Text name, int type) override;
+		KSGSVariable* getParameter(Framework::Text name) override;
+		void setExpression(Framework::Text expression) override;
+		KSGSVariable* evaluate() override;
+		void logNachricht(const char* n) override;
+		Framework::Text* convertPfad(const char* pf) override;
+		void setVariable(int id, KSGSVariable* var) override;
+		KSGSVariable* startFunktion(int id, Framework::RCArray< KSGSVariable >* parameter) override;
+		KSGSVariable* erstellKlassenInstanz(int id) override;
+		KSGSVariable* getVariable(int id) const override;
+		int getScriptId() const override;
+		Framework::Bildschirm* zBildschirm() const override;
+		Framework::Schrift* zSchrift() const override;
+		int getFunktionId(const char* name) const override;
+		bool istBeendet(int scrId) const override;
+		KSGSVariable* callback(Framework::RCArray< KSGSVariable >* parameter) const override;
+	};
 }

ksgScript/Main/KSGScriptObj.cpp

@@ -25,476 +25,476 @@ using namespace KSGScript;
 // Konstruktor
 KSGScriptO::KSGScriptO()
 {
-    pfad = new Text();
-    wd = new Text();
-    rParam = 0;
-    rFunktion = 0;
-    variablen = new RCArray< KSGSVariable >();
-    funktionen = new RCArray< KSGSFunktion >();
-    klassen = new RCArray< KSGSKlasse >();
-    schrift = 0;
-    screen = 0;
-    mainId = 0;
-    mausId = 0;
-    tastaturId = 0;
-    tickId = 0;
-    renderId = 0;
-    geladen = 0;
-    scrId = 0;
-    mausP = new RCArray< KSGSVariable >();
-    tastaturP = new RCArray< KSGSVariable >();
-    tickP = new RCArray< KSGSVariable >();
-    renderP = new RCArray< KSGSVariable >();
-    log = 0;
+	pfad = new Text();
+	wd = new Text();
+	rParam = 0;
+	rFunktion = 0;
+	variablen = new RCArray< KSGSVariable >();
+	funktionen = new RCArray< KSGSFunktion >();
+	klassen = new RCArray< KSGSKlasse >();
+	schrift = 0;
+	screen = 0;
+	mainId = 0;
+	mausId = 0;
+	tastaturId = 0;
+	tickId = 0;
+	renderId = 0;
+	geladen = 0;
+	scrId = 0;
+	mausP = new RCArray< KSGSVariable >();
+	tastaturP = new RCArray< KSGSVariable >();
+	tickP = new RCArray< KSGSVariable >();
+	renderP = new RCArray< KSGSVariable >();
+	log = 0;
 }
 
 // Destruktor
 KSGScriptO::~KSGScriptO()
 {
-    if( schrift )
-        schrift->release();
-    if( screen )
-        screen->release();
-    reset();
-    mausP->release();
-    tastaturP->release();
-    tickP->release();
-    renderP->release();
-    pfad->release();
-    wd->release();
-    variablen->release();
-    funktionen->release();
-    klassen->release();
-    if( log )
-        log->release();
+	if (schrift)
+		schrift->release();
+	if (screen)
+		screen->release();
+	reset();
+	mausP->release();
+	tastaturP->release();
+	tickP->release();
+	renderP->release();
+	pfad->release();
+	wd->release();
+	variablen->release();
+	funktionen->release();
+	klassen->release();
+	if (log)
+		log->release();
 }
 
 // nicht constant
 void KSGScriptO::lock()
 {
-    cs.lock();
+	cs.lock();
 }
 
 void KSGScriptO::unlock()
 {
-    cs.unlock();
+	cs.unlock();
 }
 
-void KSGScriptO::setScriptDatei( const char *pfad )
+void KSGScriptO::setScriptDatei(const char* pfad)
 {
-    this->pfad->setText( pfad );
-    this->pfad->ersetzen( '\\', '/' );
-    int l = this->pfad->hat( '/' ) ? this->pfad->positionVon( '/', this->pfad->anzahlVon( '/' ) - 1 ) + 1 : 0;
-    if( l )
-        wd->setText( pfad, l );
+	this->pfad->setText(pfad);
+	this->pfad->ersetzen('\\', '/');
+	int l = this->pfad->hat('/') ? this->pfad->positionVon('/', this->pfad->anzahlVon('/') - 1) + 1 : 0;
+	if (l)
+		wd->setText(pfad, l);
 }
 
-void KSGScriptO::setScriptDatei( Text *pfad )
+void KSGScriptO::setScriptDatei(Text* pfad)
 {
-    setScriptDatei( pfad->getText() );
-    pfad->release();
+	setScriptDatei(pfad->getText());
+	pfad->release();
 }
 
 bool KSGScriptO::neuLaden()
 {
-    lock();
-    ZeitMesser *gzm = new ZeitMesser();
-    gzm->messungStart();
-    if( geladen )
-        reset();
-    scrId++;
-    Datei *datei = new Datei();
-    datei->setDatei( *pfad );
-    if( !datei->open( Datei::Style::lesen ) )
-    {
-        datei->release();
-        error( 4, { *pfad }, this );
-        return 0;
-    }
-    KSGSLeser *reader = new KSGSLeser( datei, this, *pfad );
-    ZeitMesser *zm = new ZeitMesser();
-    zm->messungStart();
-    if( !reader->laden() )
-    {
-        reader->release();
-        datei->close();
-        datei->release();
-        zm->release();
-        gzm->release();
-        unlock();
-        return 0;
-    }
-    zm->messungEnde();
-    if( log )
-    {
-        Text msg = "Reader: Zum lesen benötigte Sekunden: ";
-        msg += zm->getSekunden();
-        logNachricht( msg );
-    }
-    std::cout << "KSGS Reader: Zum lesen benötigte Sekunden: " << zm->getSekunden() << "\n";
-    Array< KSGSVariableDef * > *varDefs = new Array< KSGSVariableDef * >();
-    zm->messungStart();
-    if( !reader->compile( klassen, funktionen, varDefs ) )
-    {
-        varDefs->release();
-        reader->release();
-        datei->close();
-        datei->release();
-        zm->release();
-        gzm->release();
-        unlock();
-        return 0;
-    }
-    mausP->add( new KSGSMausEreignisKlasse( this ) );
-    tastaturP->add( new KSGSTastaturEreignisKlasse( this ) );
-    tickP->add( new KSGSDoubleKlasse( this ) );
-    renderP->add( new KSGSBildKlasse( this ) );
-    zm->messungEnde();
-    if( log )
-    {
-        Text msg = "Reader: Zum compilieren benötigte Sekunden: ";
-        msg += zm->getSekunden();
-        logNachricht( msg );
-    }
-    std::cout << "KSGS Reader: Zum compilieren benötigte Sekunden: " << zm->getSekunden() << "\n";
-    zm->release();
-    int vAnz = varDefs->getEintragAnzahl();
-    for( int i = 0; i < vAnz; i++ )
-    {
-        KSGSVariable *var = KSGSKlasseInstanz::erstellVariable( this, varDefs->get( i ) );
-        if( var )
-            variablen->add( var );
-        delete varDefs->get( i );
-    }
-    varDefs->release();
-    mainId = reader->getMainFuncId();
-    mausId = reader->getMausFuncId();
-    tastaturId = reader->getTastaturFuncId();
-    tickId = reader->getTickFuncId();
-    renderId = reader->getRenderFuncId();
-    reader->release();
-    datei->close();
-    datei->release();
-    int anz = funktionen->getEintragAnzahl();
-    geladen = 1;
-    for( int i = 0; i < anz; i++ )
-    {
-        if( funktionen->z( i )->getId() == mainId )
-        {
-            KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptProcessor *>( getThis() ), 0, 0 );
-            KSGSVariable *ret = inst->startFunktion();
-            if( ret )
-                ret->release();
-            if( inst->isFunctionExecuting() )
-                inst->warteAufFunktion( INFINITE );
-            inst->release();
-            break;
-        }
-    }
-    geladen = 2;
-    gzm->messungEnde();
-    if( log )
-    {
-        Text msg = "Reader: Zum laden benötigte Sekunden: ";
-        msg += gzm->getSekunden();
-        logNachricht( msg );
-    }
-    std::cout << "KSGS Reader: Zum laden benötigte Sekunden: " << gzm->getSekunden() << "\n";
-    gzm->release();
-    unlock();
-    return 1;
+	lock();
+	ZeitMesser* gzm = new ZeitMesser();
+	gzm->messungStart();
+	if (geladen)
+		reset();
+	scrId++;
+	Datei* datei = new Datei();
+	datei->setDatei(*pfad);
+	if (!datei->open(Datei::Style::lesen))
+	{
+		datei->release();
+		error(4, { *pfad }, this);
+		return 0;
+	}
+	KSGSLeser* reader = new KSGSLeser(datei, this, *pfad);
+	ZeitMesser* zm = new ZeitMesser();
+	zm->messungStart();
+	if (!reader->laden())
+	{
+		reader->release();
+		datei->close();
+		datei->release();
+		zm->release();
+		gzm->release();
+		unlock();
+		return 0;
+	}
+	zm->messungEnde();
+	if (log)
+	{
+		Text msg = "Reader: Zum lesen benötigte Sekunden: ";
+		msg += zm->getSekunden();
+		logNachricht(msg);
+	}
+	std::cout << "KSGS Reader: Zum lesen benötigte Sekunden: " << zm->getSekunden() << "\n";
+	Array< KSGSVariableDef* >* varDefs = new Array< KSGSVariableDef* >();
+	zm->messungStart();
+	if (!reader->compile(klassen, funktionen, varDefs))
+	{
+		varDefs->release();
+		reader->release();
+		datei->close();
+		datei->release();
+		zm->release();
+		gzm->release();
+		unlock();
+		return 0;
+	}
+	mausP->add(new KSGSMausEreignisKlasse(this));
+	tastaturP->add(new KSGSTastaturEreignisKlasse(this));
+	tickP->add(new KSGSDoubleKlasse(this));
+	renderP->add(new KSGSBildKlasse(this));
+	zm->messungEnde();
+	if (log)
+	{
+		Text msg = "Reader: Zum compilieren benötigte Sekunden: ";
+		msg += zm->getSekunden();
+		logNachricht(msg);
+	}
+	std::cout << "KSGS Reader: Zum compilieren benötigte Sekunden: " << zm->getSekunden() << "\n";
+	zm->release();
+	int vAnz = varDefs->getEintragAnzahl();
+	for (int i = 0; i < vAnz; i++)
+	{
+		KSGSVariable* var = KSGSKlasseInstanz::erstellVariable(this, varDefs->get(i));
+		if (var)
+			variablen->add(var);
+		delete varDefs->get(i);
+	}
+	varDefs->release();
+	mainId = reader->getMainFuncId();
+	mausId = reader->getMausFuncId();
+	tastaturId = reader->getTastaturFuncId();
+	tickId = reader->getTickFuncId();
+	renderId = reader->getRenderFuncId();
+	reader->release();
+	datei->close();
+	datei->release();
+	int anz = funktionen->getEintragAnzahl();
+	geladen = 1;
+	for (int i = 0; i < anz; i++)
+	{
+		if (funktionen->z(i)->getId() == mainId)
+		{
+			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, 0);
+			KSGSVariable* ret = inst->startFunktion();
+			if (ret)
+				ret->release();
+			if (inst->isFunctionExecuting())
+				inst->warteAufFunktion(INFINITE);
+			inst->release();
+			break;
+		}
+	}
+	geladen = 2;
+	gzm->messungEnde();
+	if (log)
+	{
+		Text msg = "Reader: Zum laden benötigte Sekunden: ";
+		msg += gzm->getSekunden();
+		logNachricht(msg);
+	}
+	std::cout << "KSGS Reader: Zum laden benötigte Sekunden: " << gzm->getSekunden() << "\n";
+	gzm->release();
+	unlock();
+	return 1;
 }
 
 void KSGScriptO::reset()
 {
-    lock();
-    geladen = 0;
-    variablen->leeren();
-    funktionen->leeren();
-    klassen->leeren();
-    mausP->leeren();
-    tastaturP->leeren();
-    tickP->leeren();
-    renderP->leeren();
-    unlock();
-}
-
-void KSGScriptO::setCallbackParam( void *p )
-{
-    rParam = p;
-}
-
-void KSGScriptO::setCallbackFunktion( void( *funktion )( void *, RCArray< KSGSVariable > *, KSGSVariable ** ) )
-{
-    rFunktion = funktion;
-}
-
-void KSGScriptO::setSchriftZ( Schrift *s )
-{
-    if( schrift )
-        schrift->release();
-    schrift = s;
-}
-
-void KSGScriptO::setBildschirmZ( Bildschirm *s )
-{
-    if( screen )
-        screen->release();
-    screen = s;
-}
-
-void KSGScriptO::doPublicMausEreignis( MausEreignis &me )
-{
-    if( geladen != 2 )
-        return;
-    lock();
-    me.mx -= pos.x;
-    me.my -= pos.y;
-    int anz = funktionen->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( funktionen->z( i )->getId() == mausId )
-        {
-            ( (KSGSMausEreignisKlasse *)mausP->z( 0 ) )->set( me );
-            KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptProcessor *>( getThis() ), 0, dynamic_cast<RCArray<KSGSVariable>*>( mausP->getThis() ) );
-            KSGSVariable *ret = inst->startFunktion();
-            if( ret )
-            {
-                me.verarbeitet |= ret->getBool();
-                ret->release();
-            }
-            if( inst->isFunctionExecuting() )
-                inst->warteAufFunktion( INFINITE );
-            inst->release();
-            break;
-        }
-    }
-    me.mx += pos.x;
-    me.my += pos.y;
-    unlock();
-}
-
-void KSGScriptO::doTastaturEreignis( TastaturEreignis &te )
-{
-    if( geladen != 2 )
-        return;
-    lock();
-    int anz = funktionen->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( funktionen->z( i )->getId() == tastaturId )
-        {
-            ( (KSGSTastaturEreignisKlasse *)tastaturP->z( 0 ) )->set( te );
-            KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptProcessor *>( getThis() ), 0, dynamic_cast<RCArray<KSGSVariable>*>( tastaturP->getThis() ) );
-            KSGSVariable *ret = inst->startFunktion();
-            if( ret )
-            {
-                te.verarbeitet |= ret->getBool();
-                ret->release();
-            }
-            if( inst->isFunctionExecuting() )
-                inst->warteAufFunktion( INFINITE );
-            inst->release();
-            break;
-        }
-    }
-    unlock();
-}
-
-bool KSGScriptO::tick( double zeit )
-{
-    if( geladen != 2 )
-        return 0;
-    lock();
-    int anz = funktionen->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( funktionen->z( i )->getId() == tickId )
-        {
-            ( (KSGSDoubleKlasse *)tickP->z( 0 ) )->set( zeit );
-            KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptProcessor *>( getThis() ), 0, dynamic_cast<RCArray<KSGSVariable>*>( tickP->getThis() ) );
-            KSGSVariable *ret = inst->startFunktion();
-            bool r = 0;
-            if( ret )
-            {
-                r = ret->getBool();
-                ret->release();
-            }
-            if( inst->isFunctionExecuting() )
-                inst->warteAufFunktion( INFINITE );
-            inst->release();
-            unlock();
-            return r;
-        }
-    }
-    unlock();
-    return 0;
-}
-
-void KSGScriptO::render( Bild &zRObj )
-{
-    if( geladen != 2 )
-        return;
-    lock();
-    if( !zRObj.setDrawOptions( pos, gr ) )
-    {
-        unlock();
-        return;
-    }
-    int anz = funktionen->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( funktionen->z( i )->getId() == renderId )
-        {
-            ( (KSGSBildKlasse *)renderP->z( 0 ) )->set( dynamic_cast<Bild *>( zRObj.getThis() ) );
-            KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptProcessor *>( getThis() ), 0, dynamic_cast<RCArray<KSGSVariable>*>( renderP->getThis() ) );
-            KSGSVariable *ret = inst->startFunktion();
-            if( ret )
-                ret->release();
-            if( inst->isFunctionExecuting() )
-                inst->warteAufFunktion( INFINITE );
-            inst->release();
-            break;
-        }
-    }
-    zRObj.releaseDrawOptions();
-    unlock();
-}
-
-KSGSVariable *KSGScriptO::startFunktion( int id, RCArray< KSGSVariable > *parameter )
-{
-    if( !funktionen || !funktionen->z( id ) || funktionen->z( id )->getSichtbarkeit() != 0 )
-    {
-        error( 19, {}, this );
-        parameter->release();
-        return 0;
-    }
-    KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( dynamic_cast<KSGScriptProcessor *>( getThis() ), 0, parameter );
-    KSGSVariable *ret = inst->startFunktion();
-    inst->release();
-    return ret;
-}
-
-KSGSVariable *KSGScriptO::erstellKlassenInstanz( int id )
-{
-    int anz = klassen->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( klassen->z( i ) && klassen->z( i )->getId() == id )
-            return klassen->z( i )->erstellInstanz( this );
-    }
-    error( 2, {}, this );
-    return 0;
-}
-
-void KSGScriptO::setVariable( int id, KSGSVariable *var )
-{
-    variablen->set( var, id );
-}
-
-Text *KSGScriptO::convertPfad( char *pf )
-{
-    Text *ret = new Text( pf );
-    ret->ersetzen( '\\', '/' );
-    if( ret->getText()[ 0 ] == '/' )
-    {
-        ret->remove( 0 );
-        return ret;
-    }
-    ret->insert( 0, wd->getText() );
-    return ret;
-}
-
-void KSGScriptO::setLog( TextFeld *log )
-{
-    lock();
-    if( this->log )
-        this->log->release();
-    this->log = log;
-    unlock();
-}
-
-void KSGScriptO::logNachricht( char *n )
-{
-    if( log )
-    {
-        lock();
-        log->addZeile( n );
-        unlock();
-    }
+	lock();
+	geladen = 0;
+	variablen->leeren();
+	funktionen->leeren();
+	klassen->leeren();
+	mausP->leeren();
+	tastaturP->leeren();
+	tickP->leeren();
+	renderP->leeren();
+	unlock();
+}
+
+void KSGScriptO::setCallbackParam(void* p)
+{
+	rParam = p;
+}
+
+void KSGScriptO::setCallbackFunktion(void(*funktion)(void*, RCArray< KSGSVariable >*, KSGSVariable**))
+{
+	rFunktion = funktion;
+}
+
+void KSGScriptO::setSchriftZ(Schrift* s)
+{
+	if (schrift)
+		schrift->release();
+	schrift = s;
+}
+
+void KSGScriptO::setBildschirmZ(Bildschirm* s)
+{
+	if (screen)
+		screen->release();
+	screen = s;
+}
+
+void KSGScriptO::doPublicMausEreignis(MausEreignis& me)
+{
+	if (geladen != 2)
+		return;
+	lock();
+	me.mx -= pos.x;
+	me.my -= pos.y;
+	int anz = funktionen->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (funktionen->z(i)->getId() == mausId)
+		{
+			((KSGSMausEreignisKlasse*)mausP->z(0))->set(me);
+			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(mausP->getThis()));
+			KSGSVariable* ret = inst->startFunktion();
+			if (ret)
+			{
+				me.verarbeitet |= ret->getBool();
+				ret->release();
+			}
+			if (inst->isFunctionExecuting())
+				inst->warteAufFunktion(INFINITE);
+			inst->release();
+			break;
+		}
+	}
+	me.mx += pos.x;
+	me.my += pos.y;
+	unlock();
+}
+
+void KSGScriptO::doTastaturEreignis(TastaturEreignis& te)
+{
+	if (geladen != 2)
+		return;
+	lock();
+	int anz = funktionen->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (funktionen->z(i)->getId() == tastaturId)
+		{
+			((KSGSTastaturEreignisKlasse*)tastaturP->z(0))->set(te);
+			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(tastaturP->getThis()));
+			KSGSVariable* ret = inst->startFunktion();
+			if (ret)
+			{
+				te.verarbeitet |= ret->getBool();
+				ret->release();
+			}
+			if (inst->isFunctionExecuting())
+				inst->warteAufFunktion(INFINITE);
+			inst->release();
+			break;
+		}
+	}
+	unlock();
+}
+
+bool KSGScriptO::tick(double zeit)
+{
+	if (geladen != 2)
+		return 0;
+	lock();
+	int anz = funktionen->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (funktionen->z(i)->getId() == tickId)
+		{
+			((KSGSDoubleKlasse*)tickP->z(0))->set(zeit);
+			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(tickP->getThis()));
+			KSGSVariable* ret = inst->startFunktion();
+			bool r = 0;
+			if (ret)
+			{
+				r = ret->getBool();
+				ret->release();
+			}
+			if (inst->isFunctionExecuting())
+				inst->warteAufFunktion(INFINITE);
+			inst->release();
+			unlock();
+			return r;
+		}
+	}
+	unlock();
+	return 0;
+}
+
+void KSGScriptO::render(Bild& zRObj)
+{
+	if (geladen != 2)
+		return;
+	lock();
+	if (!zRObj.setDrawOptions(pos, gr))
+	{
+		unlock();
+		return;
+	}
+	int anz = funktionen->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (funktionen->z(i)->getId() == renderId)
+		{
+			((KSGSBildKlasse*)renderP->z(0))->set(dynamic_cast<Bild*>(zRObj.getThis()));
+			KSGSFunktionInstanz* inst = funktionen->z(i)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, dynamic_cast<RCArray<KSGSVariable>*>(renderP->getThis()));
+			KSGSVariable* ret = inst->startFunktion();
+			if (ret)
+				ret->release();
+			if (inst->isFunctionExecuting())
+				inst->warteAufFunktion(INFINITE);
+			inst->release();
+			break;
+		}
+	}
+	zRObj.releaseDrawOptions();
+	unlock();
+}
+
+KSGSVariable* KSGScriptO::startFunktion(int id, RCArray< KSGSVariable >* parameter)
+{
+	if (!funktionen || !funktionen->z(id) || funktionen->z(id)->getSichtbarkeit() != 0)
+	{
+		error(19, {}, this);
+		parameter->release();
+		return 0;
+	}
+	KSGSFunktionInstanz* inst = funktionen->z(id)->erstellInstanz(dynamic_cast<KSGScriptProcessor*>(getThis()), 0, parameter);
+	KSGSVariable* ret = inst->startFunktion();
+	inst->release();
+	return ret;
+}
+
+KSGSVariable* KSGScriptO::erstellKlassenInstanz(int id)
+{
+	int anz = klassen->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (klassen->z(i) && klassen->z(i)->getId() == id)
+			return klassen->z(i)->erstellInstanz(this);
+	}
+	error(2, {}, this);
+	return 0;
+}
+
+void KSGScriptO::setVariable(int id, KSGSVariable* var)
+{
+	variablen->set(var, id);
+}
+
+Text* KSGScriptO::convertPfad(const char* pf)
+{
+	Text* ret = new Text(pf);
+	ret->ersetzen('\\', '/');
+	if (ret->getText()[0] == '/')
+	{
+		ret->remove(0);
+		return ret;
+	}
+	ret->insert(0, wd->getText());
+	return ret;
+}
+
+void KSGScriptO::setLog(TextFeld* log)
+{
+	lock();
+	if (this->log)
+		this->log->release();
+	this->log = log;
+	unlock();
+}
+
+void KSGScriptO::logNachricht(const  char* n)
+{
+	if (log)
+	{
+		lock();
+		log->addZeile(n);
+		unlock();
+	}
 }
 
 // constant
-KSGSVariable *KSGScriptO::callback( RCArray< KSGSVariable > *parameter ) const
+KSGSVariable* KSGScriptO::callback(RCArray< KSGSVariable >* parameter) const
 {
-    if( !rFunktion )
-    {
-        parameter->release();
-        return 0;
-    }
-    KSGSVariable *ret = 0;
-    rFunktion( rParam, parameter, &ret );
-    parameter->release();
-    return ret;
+	if (!rFunktion)
+	{
+		parameter->release();
+		return 0;
+	}
+	KSGSVariable* ret = 0;
+	rFunktion(rParam, parameter, &ret);
+	parameter->release();
+	return ret;
 }
 
-Text *KSGScriptO::getScriptDateiPfad() const
+Text* KSGScriptO::getScriptDateiPfad() const
 {
-    return dynamic_cast<Text *>( pfad->getThis() );
+	return dynamic_cast<Text*>(pfad->getThis());
 }
 
-Text *KSGScriptO::zScriptDateiPfad() const
+Text* KSGScriptO::zScriptDateiPfad() const
 {
-    return pfad;
+	return pfad;
 }
 
-Schrift *KSGScriptO::getSchrift() const
+Schrift* KSGScriptO::getSchrift() const
 {
-    return schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0;
+	return schrift ? dynamic_cast<Schrift*>(schrift->getThis()) : 0;
 }
 
-Schrift *KSGScriptO::zSchrift() const
+Schrift* KSGScriptO::zSchrift() const
 {
-    return schrift;
+	return schrift;
 }
 
-Bildschirm *KSGScriptO::getBildschirm() const
+Bildschirm* KSGScriptO::getBildschirm() const
 {
-    return screen ? dynamic_cast<Bildschirm *>( screen->getThis() ) : 0;
+	return screen ? dynamic_cast<Bildschirm*>(screen->getThis()) : 0;
 }
 
-Bildschirm *KSGScriptO::zBildschirm() const
+Bildschirm* KSGScriptO::zBildschirm() const
 {
-    return screen;
+	return screen;
 }
 
 int KSGScriptO::getScriptId() const
 {
-    return scrId;
+	return scrId;
 }
 
-bool KSGScriptO::istBeendet( int scrId ) const
+bool KSGScriptO::istBeendet(int scrId) const
 {
-    return !geladen || this->scrId != scrId;
+	return !geladen || this->scrId != scrId;
 }
 
-int KSGScriptO::getFunktionId( const char *name ) const
+int KSGScriptO::getFunktionId(const char* name) const
 {
-    int anz = funktionen->getEintragAnzahl();
-    for( int i = 0; i < anz; i++ )
-    {
-        if( funktionen->z( i )->hatName( name ) )
-            return i;
-    }
-    return -1;
+	int anz = funktionen->getEintragAnzahl();
+	for (int i = 0; i < anz; i++)
+	{
+		if (funktionen->z(i)->hatName(name))
+			return i;
+	}
+	return -1;
 }
 
-KSGSVariable *KSGScriptO::getVariable( int id ) const
+KSGSVariable* KSGScriptO::getVariable(int id) const
 {
-    if( !variablen || !variablen->z( id ) )
-    {
-        error( 17, {}, (KSGScriptO *)this );
-        return 0;
-    }
-    return variablen->get( id );
+	if (!variablen || !variablen->z(id))
+	{
+		error(17, {}, (KSGScriptO*)this);
+		return 0;
+	}
+	return variablen->get(id);
 }

ksgScript/Main/KSGScriptObj.h

@@ -11,74 +11,74 @@ using namespace Framework;
 
 namespace KSGScript
 {
-    class KSGSFunktion; // ../Befehl/KSGSFunktion.h
-    class KSGSFunktionInstanz; // ../Befehl/KSGSFunktion.h
-    class KSGSKlasse; // ../Befehl/KSGSKlasse.h
-    class KSGSKlasseInstanz; // ../Befehl/KSGSKlasse.h
+	class KSGSFunktion; // ../Befehl/KSGSFunktion.h
+	class KSGSFunktionInstanz; // ../Befehl/KSGSFunktion.h
+	class KSGSKlasse; // ../Befehl/KSGSKlasse.h
+	class KSGSKlasseInstanz; // ../Befehl/KSGSKlasse.h
 
-    class KSGScriptO : public KSGScriptObj
-    {
-    private:
-        Text *pfad;
-        Text *wd;
-        void *rParam;
-        void( *rFunktion )( void *, RCArray< KSGSVariable > *, KSGSVariable ** );
-        RCArray< KSGSVariable > *variablen;
-        RCArray< KSGSFunktion > *funktionen;
-        RCArray< KSGSKlasse > *klassen;
-        Schrift *schrift;
-        Bildschirm *screen;
-        RCArray< KSGSVariable > *mausP;
-        RCArray< KSGSVariable > *tastaturP;
-        RCArray< KSGSVariable > *tickP;
-        RCArray< KSGSVariable > *renderP;
-        TextFeld *log;
-        int mainId;
-        int mausId;
-        int tastaturId;
-        int tickId;
-        int renderId;
-        int geladen;
-        int scrId;
-        Critical cs;
+	class KSGScriptO : public KSGScriptObj
+	{
+	private:
+		Text* pfad;
+		Text* wd;
+		void* rParam;
+		void(*rFunktion)(void*, RCArray< KSGSVariable >*, KSGSVariable**);
+		RCArray< KSGSVariable >* variablen;
+		RCArray< KSGSFunktion >* funktionen;
+		RCArray< KSGSKlasse >* klassen;
+		Schrift* schrift;
+		Bildschirm* screen;
+		RCArray< KSGSVariable >* mausP;
+		RCArray< KSGSVariable >* tastaturP;
+		RCArray< KSGSVariable >* tickP;
+		RCArray< KSGSVariable >* renderP;
+		TextFeld* log;
+		int mainId;
+		int mausId;
+		int tastaturId;
+		int tickId;
+		int renderId;
+		int geladen;
+		int scrId;
+		Critical cs;
 
-    public:
-        // Konstruktor
-        __declspec( dllexport ) KSGScriptO();
-        // Destruktor
-        __declspec( dllexport ) ~KSGScriptO();
-        // nicht constant
-        virtual void lock() override;
-        virtual void unlock() override;
-        virtual void setScriptDatei( const char *pfad ) override;
-        virtual void setScriptDatei( Text *pfad ) override;
-        virtual bool neuLaden() override;
-        virtual void reset() override;
-        virtual void setCallbackParam( void *p ) override;
-        virtual void setCallbackFunktion( void( *funktion )( void *, RCArray< KSGSVariable > *, KSGSVariable ** ) ) override;
-        virtual void setSchriftZ( Schrift *s ) override;
-        virtual void setBildschirmZ( Bildschirm *s ) override;
-        virtual void doPublicMausEreignis( MausEreignis &me ) override;
-        virtual void doTastaturEreignis( TastaturEreignis &te ) override;
-        virtual bool tick( double zeit ) override;
-        virtual void render( Bild &zRObj ) override;
-        virtual KSGSVariable *startFunktion( int id, RCArray< KSGSVariable > *parameter ) override;
-        virtual KSGSVariable *erstellKlassenInstanz( int id ) override;
-        virtual void setVariable( int id, KSGSVariable *var ) override;
-        virtual Text *convertPfad( char *pf ) override;
-        virtual void setLog( TextFeld *log ) override;
-        virtual void logNachricht( char *n ) override;
-        // constant
-        virtual KSGSVariable *callback( RCArray< KSGSVariable > *parameter ) const override;
-        virtual Text *getScriptDateiPfad() const override;
-        virtual Text *zScriptDateiPfad() const override;
-        virtual Schrift *getSchrift() const override;
-        virtual Schrift *zSchrift() const override;
-        virtual Bildschirm *getBildschirm() const override;
-        virtual Bildschirm *zBildschirm() const override;
-        virtual int getScriptId() const override;
-        virtual bool istBeendet( int scrId ) const override;
-        virtual int getFunktionId( const char *name ) const override;
-        virtual KSGSVariable *getVariable( int id ) const override;
-    };
+	public:
+		// Konstruktor
+		__declspec(dllexport) KSGScriptO();
+		// Destruktor
+		__declspec(dllexport) ~KSGScriptO();
+		// nicht constant
+		virtual void lock() override;
+		virtual void unlock() override;
+		virtual void setScriptDatei(const char* pfad) override;
+		virtual void setScriptDatei(Text* pfad) override;
+		virtual bool neuLaden() override;
+		virtual void reset() override;
+		virtual void setCallbackParam(void* p) override;
+		virtual void setCallbackFunktion(void(*funktion)(void*, RCArray< KSGSVariable >*, KSGSVariable**)) override;
+		virtual void setSchriftZ(Schrift* s) override;
+		virtual void setBildschirmZ(Bildschirm* s) override;
+		virtual void doPublicMausEreignis(MausEreignis& me) override;
+		virtual void doTastaturEreignis(TastaturEreignis& te) override;
+		virtual bool tick(double zeit) override;
+		virtual void render(Bild& zRObj) override;
+		virtual KSGSVariable* startFunktion(int id, RCArray< KSGSVariable >* parameter) override;
+		virtual KSGSVariable* erstellKlassenInstanz(int id) override;
+		virtual void setVariable(int id, KSGSVariable* var) override;
+		virtual Text* convertPfad(const char* pf) override;
+		virtual void setLog(TextFeld* log) override;
+		virtual void logNachricht(const char* n) override;
+		// constant
+		virtual KSGSVariable* callback(RCArray< KSGSVariable >* parameter) const override;
+		virtual Text* getScriptDateiPfad() const override;
+		virtual Text* zScriptDateiPfad() const override;
+		virtual Schrift* getSchrift() const override;
+		virtual Schrift* zSchrift() const override;
+		virtual Bildschirm* getBildschirm() const override;
+		virtual Bildschirm* zBildschirm() const override;
+		virtual int getScriptId() const override;
+		virtual bool istBeendet(int scrId) const override;
+		virtual int getFunktionId(const char* name) const override;
+		virtual KSGSVariable* getVariable(int id) const override;
+	};
 }