Simpler Script Editor mit standartfunktionen wie Code Einfärbung und einfacher Fehlererkennung hinzugefügt

ksgScript/Befehl/KSGSBefehl.cpp

@@ -528,7 +528,7 @@ KSGSBefehl::~KSGSBefehl()
 }
 
 // constant
-KSGSVariable *KSGSBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	return 0;
 }
@@ -564,7 +564,7 @@ KSGSBefehl *KSGSBefehl::release()
 }
 
 // static
-KSGSVariable *KSGSBefehl::prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI )
+KSGSVariable *KSGSBefehl::prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
 {
 	if( !zVar )
 	{
@@ -596,7 +596,7 @@ KSGSVariable *KSGSBefehl::prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVari
 	return 0;
 }
 
-KSGSVariable *KSGSBefehl::prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunktion *zFunk, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI )
+KSGSVariable *KSGSBefehl::prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunktion *zFunk, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
 {
 	if( !zFunk )
 	{
@@ -629,7 +629,7 @@ KSGSVariable *KSGSBefehl::prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunk
 	return 0;
 }
 
-KSGSVariable *KSGSBefehl::prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember *zMem, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI )
+KSGSVariable *KSGSBefehl::prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember *zMem, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
 {
 	if( !zMem )
 	{
@@ -655,7 +655,7 @@ KSGSVariable *KSGSBefehl::prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember
 	return 0;
 }
 
-KSGSVariable *KSGSBefehl::prozessParameter( KSGSBefehlParameter *zParam, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI )
+KSGSVariable *KSGSBefehl::prozessParameter( KSGSBefehlParameter *zParam, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
 {
 	if( !zParam )
 	{
@@ -731,7 +731,7 @@ KSGSVariable *KSGSBefehl::prozessParameter( KSGSBefehlParameter *zParam, KSGScri
 	return 0;
 }
 
-KSGSVariable *KSGSBefehl::prozessErstell( KSGSBefehlErstell *zErst, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI )
+KSGSVariable *KSGSBefehl::prozessErstell( KSGSBefehlErstell *zErst, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
 {
 	if( !zErst )
 	{
@@ -744,7 +744,7 @@ KSGSVariable *KSGSBefehl::prozessErstell( KSGSBefehlErstell *zErst, KSGScriptObj
 	if( !ret )
 	{
 		KSGSVariableDef def = { zErst->typId, zErst->id, 3, "" };
-		ret = KSGSVariable::erstellVariable( zObj, &def );
+		ret = KSGSKlasseInstanz::erstellVariable( zObj, &def );
 	}
 	if( !ret )
 	{
@@ -809,7 +809,7 @@ KSGSCallBefehl::~KSGSCallBefehl()
 }
 
 // constant
-KSGSVariable *KSGSCallBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSCallBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	KSGSVariable *v = 0;
 	int anz = objekt.getEintragAnzahl();
@@ -882,7 +882,7 @@ KSGSOperatorBefehl::~KSGSOperatorBefehl()
 }
 
 // constant
-KSGSVariable *KSGSOperatorBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSOperatorBefehl::ausführen( KSGScriptObj *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 ) )
@@ -1135,7 +1135,7 @@ KSGSIfBefehl::~KSGSIfBefehl()
 }
 
 // constant
-KSGSVariable *KSGSIfBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSIfBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
 	if( !b )
@@ -1319,7 +1319,7 @@ KSGSForBefehl::~KSGSForBefehl()
 }
 
 // constant
-KSGSVariable *KSGSForBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSForBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	KSGSVariable *l = links ? links->ausführen( zObj, zFI, zKI ) : 0;
 	if( l )
@@ -1443,7 +1443,7 @@ KSGSWhileBefehl::~KSGSWhileBefehl()
 }
 
 // constant
-KSGSVariable *KSGSWhileBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSWhileBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
 	if( !b )
@@ -1520,7 +1520,7 @@ KSGSReturnBefehl::~KSGSReturnBefehl()
 }
 
 // constant
-KSGSVariable *KSGSReturnBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSReturnBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	KSGSVariable *v = param ? prozessParameter( param, zObj, zFI, zKI ) : 0;
 	if( v )
@@ -1554,7 +1554,7 @@ KSGSBreakBefehl::~KSGSBreakBefehl()
 }
 
 // constant
-KSGSVariable *KSGSBreakBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSBreakBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	zFI->setBreak();
 	return 0;
@@ -1585,7 +1585,7 @@ KSGSContinueBefehl::~KSGSContinueBefehl()
 }
 
 // constant
-KSGSVariable *KSGSContinueBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSContinueBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	zFI->setContinue();
 	return 0;
@@ -1632,7 +1632,7 @@ KSGSVariableBefehl::~KSGSVariableBefehl()
 }
 
 // constant
-KSGSVariable *KSGSVariableBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const
+KSGSVariable *KSGSVariableBefehl::ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
 {
 	return prozessErstell( erstell, zObj, zFI, zKI );
 }

ksgScript/Befehl/KSGSBefehl.h

@@ -17,8 +17,7 @@ namespace KSGScript
 	class KSGSCompVarTable; // ../Leser/Compile.h
 	class KSGSBefehl; // aus dieser Datei
 	class KSGSFunktionInstanz; // KSGSFunktion
-	class KSGSKlasseInstanz; // KSGSKlasse.h
-	typedef KSGSKlasseInstanz KSGSVariable;
+	class KSGSVariable; // KSGSKlasse.h
 
 	struct KSGSBefehlVariable
 	{
@@ -118,7 +117,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const;
 		__declspec( dllexport ) bool hatFehler() const;
 		__declspec( dllexport ) int getReturnTyp() const;
 		__declspec( dllexport ) bool istTyp( Typ t ) const;
@@ -126,11 +125,11 @@ namespace KSGScript
 		__declspec( dllexport ) KSGSBefehl *getThis();
 		__declspec( dllexport ) virtual KSGSBefehl *release();
 		// static
-		__declspec( dllexport ) static KSGSVariable *prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI );
-		__declspec( dllexport ) static KSGSVariable *prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunktion *zFunk, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI );
-		__declspec( dllexport ) static KSGSVariable *prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember *zMem, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI );
-		__declspec( dllexport ) static KSGSVariable *prozessParameter( KSGSBefehlParameter *zParam, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI );
-		__declspec( dllexport ) static KSGSVariable *prozessErstell( KSGSBefehlErstell *zErst, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI );
+		__declspec( dllexport ) static KSGSVariable *prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI );
+		__declspec( dllexport ) static KSGSVariable *prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunktion *zFunk, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI );
+		__declspec( dllexport ) static KSGSVariable *prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember *zMem, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI );
+		__declspec( dllexport ) static KSGSVariable *prozessParameter( KSGSBefehlParameter *zParam, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI );
+		__declspec( dllexport ) static KSGSVariable *prozessErstell( KSGSBefehlErstell *zErst, KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI );
 	};
 
 	class KSGSCallBefehl : public KSGSBefehl
@@ -145,7 +144,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSCallBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -164,7 +163,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSOperatorBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -183,7 +182,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSIfBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -203,7 +202,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSForBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -221,7 +220,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSWhileBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -238,7 +237,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSReturnBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -254,7 +253,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSBreakBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -270,7 +269,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSContinueBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};
@@ -287,7 +286,7 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSVariableBefehl();
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSKlasseInstanz *zKI ) const override;
+		__declspec( dllexport ) virtual KSGSVariable *ausführen( KSGScriptObj *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSBefehl *release() override;
 	};

ksgScript/Befehl/KSGSFunktion.cpp

@@ -10,7 +10,7 @@ using namespace KSGScript;
 
 // Inhalt der KSGSFunktionInstanz Klasse aus KSGSFunktion.h
 // Konstruktor
-KSGSFunktionInstanz::KSGSFunktionInstanz( RCArray< KSGSBefehl > *ba, int rt, KSGScriptObj *obj, KSGSKlasseInstanz *klasse )
+KSGSFunktionInstanz::KSGSFunktionInstanz( RCArray< KSGSBefehl > *ba, int rt, KSGScriptObj *obj, KSGSVariable *klasse )
     : Thread()
 {
 	lokaleVariablen = new RCArray< KSGSVariable >();
@@ -66,7 +66,7 @@ void KSGSFunktionInstanz::setParameter( Array< KSGSVariableDef* > *zDef, RCArray
 			{
 				KSGSVariable *var = vars->z( id )->umwandelnIn( zDef->get( i )->typId );
 				if( !var )
-					lokaleVariablen->set( KSGSVariable::erstellVariable( obj, zDef->get( i ) ), id );
+					lokaleVariablen->set( KSGSKlasseInstanz::erstellVariable( obj, zDef->get( i ) ), id );
 				else
 					lokaleVariablen->set( var, id );
 			}
@@ -74,7 +74,7 @@ void KSGSFunktionInstanz::setParameter( Array< KSGSVariableDef* > *zDef, RCArray
 				lokaleVariablen->set( vars->get( id ), id );
 		}
 		else
-			lokaleVariablen->set( KSGSVariable::erstellVariable( obj, zDef->get( i ) ), id );
+			lokaleVariablen->set( KSGSKlasseInstanz::erstellVariable( obj, zDef->get( i ) ), id );
 	}
 	vars->release();
 }
@@ -274,7 +274,7 @@ void KSGSFunktion::addBefehl( KSGSBefehl *befehl )
 	befehle->add( befehl );
 }
 
-KSGSFunktionInstanz *KSGSFunktion::erstellInstanz( KSGScriptObj *obj, KSGSKlasseInstanz *klasse, RCArray< KSGSVariable > *params )
+KSGSFunktionInstanz *KSGSFunktion::erstellInstanz( KSGScriptObj *obj, KSGSVariable *klasse, RCArray< KSGSVariable > *params )
 {
 	KSGSFunktionInstanz *inst = new KSGSFunktionInstanz( befehle->getThis(), typId, obj, klasse );
 	if( params )

ksgScript/Befehl/KSGSFunktion.h

@@ -2,7 +2,6 @@
 #define KSGSFunktion_H
 
 #include "KSGSBefehl.h"
-#include "KSGSVariable.h"
 #include <Thread.h>
 #include <Critical.h>
 
@@ -11,14 +10,15 @@ namespace KSGScript
 	class KSGScriptObj; // ../Main/KSGScript.h
 	class KSGSKlasseInstanz; // KSGSKlasse.h
 	class KSGSThreadKlasse; // ../Klassen/KSGSThread.h
-	typedef KSGSKlasseInstanz KSGSVariable;
+    class KSGSVariable;
+    struct KSGSVariableDef;
 
 	class KSGSFunktionInstanz : private Thread
 	{
 	protected:
 		RCArray< KSGSVariable > *lokaleVariablen;
 		RCArray< KSGSBefehl > *befehle;
-		KSGSKlasseInstanz *klasse;
+        KSGSVariable *klasse;
 		KSGScriptObj *obj;
 		KSGSThreadKlasse *threadVar;
 		int returnTyp;
@@ -38,7 +38,7 @@ namespace KSGScript
 
 	public:
 		// Konstruktor
-		__declspec( dllexport ) KSGSFunktionInstanz( RCArray< KSGSBefehl > *ba, int rt, KSGScriptObj *obj, KSGSKlasseInstanz *klasse );
+		__declspec( dllexport ) KSGSFunktionInstanz( RCArray< KSGSBefehl > *ba, int rt, KSGScriptObj *obj, KSGSVariable *klasse );
 		// Destruktor
 		__declspec( dllexport ) ~KSGSFunktionInstanz();
 		// nicht constant
@@ -83,7 +83,7 @@ namespace KSGScript
 		__declspec( dllexport ) virtual void setName( const char *txt );
 		__declspec( dllexport ) virtual void addParameter( KSGSVariableDef *var );
 		__declspec( dllexport ) virtual void addBefehl( KSGSBefehl *befehl );
-		__declspec( dllexport ) virtual KSGSFunktionInstanz *erstellInstanz( KSGScriptObj *obj, KSGSKlasseInstanz *klasse, RCArray< KSGSVariable > *params );
+		__declspec( dllexport ) virtual KSGSFunktionInstanz *erstellInstanz( KSGScriptObj *obj, KSGSVariable *klasse, RCArray< KSGSVariable > *params );
 		// constant
 		__declspec( dllexport ) virtual int getId() const;
 		__declspec( dllexport ) virtual int getTypId() const;

ksgScript/Befehl/KSGSKlasse.cpp

@@ -32,7 +32,7 @@ KSGSKlasseInstanz::KSGSKlasseInstanz( int typ, Array< KSGSVariableDef* > *zVars,
 	int anz = zVars ? zVars->getEintragAnzahl() : 0;
 	for( int i = 0; i < anz; i++ )
 	{
-		lokaleVariablen->set( KSGSVariable::erstellVariable( zObj, zVars->get( i ) ), zVars->get( i )->id + 1 );
+		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;
@@ -63,7 +63,7 @@ KSGSVariable *KSGSKlasseInstanz::startFunktion( int id, bool zugriff, RCArray< K
 		parameter->release();
 		return 0;
 	}
-	KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( obj->getThis(), (KSGSKlasseInstanz*)getThis(), parameter );
+	KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( (KSGScriptO*)obj->getThis(), (KSGSKlasseInstanz*)getThis(), parameter );
 	KSGSVariable *ret = inst->startFunktion();
 	inst->release();
 	return ret;

ksgScript/Befehl/KSGSKlasse.h

@@ -6,12 +6,13 @@
 #include <Bild.h>
 #include <Animation.h>
 #include "KSGSFunktion.h"
+#include "../Include/KSGScript.h"
 
 namespace KSGScript
 {
 	class KSGSKlasse; // aus dieser Datei
 
-	class KSGSKlasseInstanz
+	class KSGSKlasseInstanz : public KSGSVariable
 	{
 	protected:
 		RCArray< KSGSVariable > *lokaleVariablen;
@@ -23,38 +24,38 @@ namespace KSGScript
 
 	public:
 		// Konstruktor
-		__declspec( dllexport ) KSGSKlasseInstanz( int typ, Array< KSGSVariableDef* > *zVars, RCArray< KSGSFunktion > *funcs, KSGScriptObj *zObj );
+		KSGSKlasseInstanz( int typ, Array< KSGSVariableDef* > *zVars, RCArray< KSGSFunktion > *funcs, KSGScriptObj *zObj );
 		// Destruktor
-		__declspec( dllexport ) ~KSGSKlasseInstanz();
+		~KSGSKlasseInstanz();
 		// nicht constant
-		__declspec( dllexport ) virtual KSGSVariable *startFunktion( int id, bool zugriff, RCArray< KSGSVariable > *parameter );
-		__declspec( dllexport ) virtual KSGSVariable *doOperator( int id, KSGSVariable *rechts );
-		__declspec( dllexport ) virtual void setVariable( int id, KSGSVariable *var );
+		virtual KSGSVariable *startFunktion( int id, bool zugriff, RCArray< KSGSVariable > *parameter ) override;
+		virtual KSGSVariable *doOperator( int id, KSGSVariable *rechts ) override;
+		virtual void setVariable( int id, KSGSVariable *var ) override;
 		// constant
-		__declspec( dllexport ) virtual KSGSVariable *getVariable( int id, bool zugriff ) const;
-		__declspec( dllexport ) virtual KSGSVariable *umwandelnIn( int typ ) const;
-		__declspec( dllexport ) virtual int getTyp() const;
+		virtual KSGSVariable *getVariable( int id, bool zugriff ) const override;
+		virtual KSGSVariable *umwandelnIn( int typ ) const override;
+		virtual int getTyp() const override;
 		// verarbeiten
-		__declspec( dllexport ) virtual bool getBool() const;
-		__declspec( dllexport ) virtual int getInt() const;
-		__declspec( dllexport ) virtual double getDouble() const;
-		__declspec( dllexport ) virtual Text *getText() const;
-		__declspec( dllexport ) virtual Bild *getBild() const;
-		__declspec( dllexport ) virtual MausEreignis getMausEreignis() const;
-		__declspec( dllexport ) virtual TastaturEreignis getTastaturEreignis() const;
-		__declspec( dllexport ) virtual TextFeld *getTextFeld() const;
-		__declspec( dllexport ) virtual Knopf *getKnopf() const;
-		__declspec( dllexport ) virtual Fenster *getFenster() const;
-		__declspec( dllexport ) virtual BildZ *getBildZ() const;
-		__declspec( dllexport ) virtual Animation2DData *getAnimation2DData() const;
-		__declspec( dllexport ) virtual Animation2D *getAnimation2D() const;
-		__declspec( dllexport ) virtual Zeichnung *getZeichnung() const;
-		__declspec( dllexport ) virtual RCArray< KSGSVariable > *getArray() const;
+		virtual bool getBool() const override;
+		virtual int getInt() const override;
+		virtual double getDouble() const override;
+		virtual Text *getText() const override;
+		virtual Bild *getBild() const override;
+		virtual MausEreignis getMausEreignis() const override;
+		virtual TastaturEreignis getTastaturEreignis() const override;
+		virtual TextFeld *getTextFeld() const override;
+		virtual Knopf *getKnopf() const override;
+		virtual Fenster *getFenster() const override;
+		virtual BildZ *getBildZ() const override;
+		virtual Animation2DData *getAnimation2DData() const override;
+		virtual Animation2D *getAnimation2D() const override;
+		virtual Zeichnung *getZeichnung() const override;
+        virtual RCArray< KSGSVariable > *getArray() const override;
 		// Reference Counting
-		__declspec( dllexport ) virtual KSGSVariable *getThis();
-		__declspec( dllexport ) virtual KSGSVariable *release();
+		virtual KSGSVariable *getThis() override;
+		virtual KSGSVariable *release() override;
 		// static
-		__declspec( dllexport ) static KSGSVariable *erstellVariable( KSGScriptObj *zObj, KSGSVariableDef *def );
+		static KSGSVariable *erstellVariable( KSGScriptObj *zObj, KSGSVariableDef *def );
 	};
 
 	class KSGSKlasse

ksgScript/Befehl/KSGSVariable.h

@@ -1,19 +0,0 @@
-#ifndef KSGSVariable_H
-#define KSGSVariable_H
-
-#include <Text.h>
-
-using namespace Framework;
-
-namespace KSGScript
-{
-	struct KSGSVariableDef
-	{
-		int typId;
-		int id;
-		int sichtbar; // 0 = global, 1 = global in klasse, 2 = lokal in klasse, 3 = lokal in Funktion
-		Text wert;
-	};
-}
-
-#endif

ksgScript/Editor/Editor.cpp

@@ -0,0 +1,682 @@
+#include "Editor.h"
+
+#include <Schrift.h>
+#include "Parser\ColorParser.h"
+#include <Bild.h>
+#include <Scroll.h>
+#include <Globals.h>
+#include <Rahmen.h>
+#include <ToolTip.h>
+
+using namespace KSGScript;
+
+// Inhalt der Editor Klasse
+// Konstructor
+Editor::Editor()
+    : ZeichnungHintergrund(),
+    begF( 0 ),
+    cPos( 0 ),
+    tickVal( 0 ),
+    mausKlick( 0 )
+{
+    ref = 1;
+    schrift = 0;
+    script = 0;
+    errorDetection = 1;
+    warningDetection = 1;
+    setTextColor( 0xFFFFFFFF, ColorType::NORMAL_TEXT );
+    setTextColor( 0xFF4040FF, ColorType::KEYWORD );
+    setTextColor( 0xFFA0A040, ColorType::PARAMETER_VARIABLE );
+    setTextColor( 0xFFA0A0A0, ColorType::INSTANCE_VARIABLE );
+    setTextColor( 0xFF40FF70, ColorType::TYPENAME );
+    setTextColor( 0xFFFFA000, ColorType::STRING );
+    setTextColor( 0xFFFF4040, ColorType::ERROR_UNDERLINE );
+    parser = 0;
+    reloadCounter = 10;
+}
+
+// Destructor
+Editor::~Editor()
+{
+    if( schrift )
+        schrift->release();
+    if( script )
+        script->release();
+    if( parser )
+        parser->release();
+}
+
+void Editor::updateHScroll( int pos )
+{
+    if( pos == -1 )
+        pos = cPos;
+    if( horizontalScrollBar && script && schrift )
+    {
+        schrift->lock();
+        schrift->setSchriftSize( 12 );
+        int br = gr.x;
+        if( hatStyle( Style::Rahmen ) && rahmen )
+            br -= rahmen->getRBreite() * 2;
+        if( hatStyle( Style::VScroll ) && vertikalScrollBar )
+            br -= 15;
+        int maxBr = schrift->getTextBreite( script ) + 12;
+        horizontalScrollBar->update( maxBr, br );
+        if( hatStyle( Style::Erlaubt ) && maxBr > br && pos > 0 && pos < script->getLength() )
+        {
+            int p1 = 0;
+            char *tmp = script->getText();
+            for( int i = 0; i < pos; i++, tmp++ )
+            {
+                if( *tmp == '\n' )
+                    p1 = i + 1;
+            }
+            Text *t = script->getTeilText( p1, pos );
+            int cbr = schrift->getTextBreite( t );
+            t->release();
+            if( cbr + 12 > horizontalScrollBar->getScroll() + horizontalScrollBar->getScrollData()->anzeige )
+                horizontalScrollBar->scroll( cbr + 12 - br );
+            if( cbr - 12 < horizontalScrollBar->getScroll() )
+                horizontalScrollBar->scroll( cbr - 12 );
+        }
+        schrift->unlock();
+    }
+}
+
+void Editor::updateVScroll( int pos )
+{
+    if( pos == -1 )
+        pos = cPos;
+    if( vertikalScrollBar )
+    {
+        int sPos = 0;
+        int hi = 0;
+        if( script && schrift )
+        {
+            schrift->setSchriftSize( 12 );
+            hi = gr.y;
+            if( hatStyle( Style::Rahmen ) && rahmen )
+                hi -= rahmen->getRBreite() * 2;
+            if( hatStyle( Style::HScroll ) && horizontalScrollBar )
+                hi -= 15;
+            vertikalScrollBar->update( schrift->getTextHeight( script ) + 12 + schrift->getTextHeight( Text( "a" ).getThis() ), hi );
+            Text t;
+            int zh = schrift->getTextHeight( &t ) + schrift->getZeilenabstand();
+            int l = script->getLength();
+            for( int i = 0; i < l && ( i < pos || hatStyleNicht( Style::Erlaubt ) ); ++i )
+            {
+                if( script->getText()[ i ] == '\n' )
+                    sPos += zh;
+            }
+        }
+        if( schrift )
+        {
+            if( sPos - schrift->getZeilenabstand() - schrift->getTextHeight( Text( "a" ).getThis() ) < vertikalScrollBar->getScroll() )
+                vertikalScrollBar->scroll( sPos - schrift->getZeilenabstand() - schrift->getTextHeight( Text( "a" ).getThis() ) );
+            if( sPos + schrift->getZeilenabstand() + schrift->getTextHeight( Text( "a" ).getThis() ) > vertikalScrollBar->getScroll() + vertikalScrollBar->getScrollData()->anzeige )
+                vertikalScrollBar->scroll( sPos + ( schrift->getZeilenabstand() + schrift->getTextHeight( Text( "a" ).getThis() ) ) * 2 - hi );
+        }
+        rend = 1;
+    }
+}
+
+// Setzt die zu verwendende Schrift
+//  s: Die Schrift
+void Editor::setSchriftZ( Schrift *s )
+{
+    if( schrift )
+        schrift->release();
+    schrift = s;
+}
+
+// Setzt den Text (das Script was verändert werden soll)
+//  txt: Der Text
+void Editor::setText( Text *txt )
+{
+    if( script )
+        script->release();
+    if( parser )
+        parser->release();
+    script = new Text( txt->getText() );
+    parser = new ColorParser( script );
+    txt->release();
+    updateHScroll( -1 );
+    updateVScroll( -1 );
+}
+
+// Gibt den aktuellen Text zurück
+Text *Editor::zText() const
+{
+    return script;
+}
+
+// Schaltet die Fehlererkennung ein oder aus
+//  on: 1, um die Fehlererkennung einzuschalten, 0 um sie auszuschalten
+void Editor::setErrorDetection( bool on )
+{
+    errorDetection = on;
+}
+
+// Schaltet die Warnungserkennung ein oder aus
+//  on: 1, um die Warnungserkennung einzuschalten, 0 um sie auszuschalten
+void Editor::setWarningDetection( bool on )
+{
+    warningDetection = on;
+}
+
+// gibt 1 zurück, wenn die Fehlererkennung eingeschaltet ist
+bool Editor::getErrorDetection() const
+{
+    return errorDetection;
+}
+
+// gibt 1 zurück, wenn die Warnungserkennung eingeschaltet ist
+bool Editor::getWarningDetection() const
+{
+    return warningDetection;
+}
+
+// Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
+//  me: Das Ereignis
+void Editor::doMausEreignis( MausEreignis &me )
+{
+    bool nmakc = !me.verarbeitet;
+    if( hatStyleNicht( Style::Erlaubt ) || hatStyleNicht( Style::Sichtbar ) )
+    {
+        if( toolTip )
+            toolTip->setMausIn( 0 );
+        me.mx -= pos.x, me.my -= pos.y;
+        int rbr = 0;
+        if( rahmen )
+            rbr = rahmen->getRBreite();
+        if( ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ||
+            ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ) &&
+            me.mx > rbr && me.mx < gr.x - rbr &&
+            me.my > rbr && me.my < gr.y - rbr )
+        {
+            vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me );
+            horizontalScrollBar->doMausMessage( rbr, gr.y - rbr * 2 - 15, gr.x - rbr * 2 - ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? 15 : 0 ), 15, me );
+            me.verarbeitet = 1;
+        }
+        me.mx += pos.x, me.my += pos.y;
+        mausKlick = 0;
+        return;
+    }
+    bool removeFokus = 0;
+    if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
+    {
+        if( mausIn )
+        {
+            mausIn = 0;
+            if( toolTip )
+                toolTip->setMausIn( 0 );
+            MausEreignis me2;
+            me2.id = ME_Leaves;
+            me2.mx = me.mx;
+            me2.my = me.my;
+            me2.verarbeitet = 0;
+            doMausEreignis( me2 );
+            return;
+        }
+        removeFokus = 1;
+    }
+    if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Leaves )
+    {
+        if( removeFokus && me.id == ME_RLinks )
+        {
+            me.mx -= pos.x, me.my -= pos.y;
+            if( hatStyle( Style::Fokus ) && mak && ( me.verarbeitet || mak( makParam, this, me ) ) )
+                removeStyle( Style::Fokus );
+            if( nmakc && me.verarbeitet && nMak )
+                me.verarbeitet = nMak( nmakParam, this, me );
+            me.mx += pos.x, me.my += pos.y;
+        }
+        if( toolTip )
+            toolTip->setMausIn( 0 );
+        return;
+    }
+    if( !mausIn && me.id != ME_Leaves )
+    {
+        mausIn = 1;
+        if( toolTip )
+            toolTip->setMausIn( 1 );
+        MausEreignis me2;
+        me2.id = ME_Betritt;
+        me2.mx = me.mx;
+        me2.my = me.my;
+        me2.verarbeitet = 0;
+        doMausEreignis( me2 );
+    }
+    me.mx -= pos.x, me.my -= pos.y;
+    if( mak && ( me.verarbeitet || mak( makParam, this, me ) ) )
+    {
+        if( removeFokus && me.id == ME_RLinks )
+            removeStyle( Style::Fokus );
+        if( !me.verarbeitet )
+        {
+            if( hatStyleNicht( Style::Fokus ) )
+            {
+                mausKlick = 0;
+                if( me.id == Framework::ME_PLinks )
+                    addStyle( Style::Fokus );
+            }
+            int rbr = 0;
+            if( rahmen )
+                rbr = rahmen->getRBreite();
+            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
+            {
+                if( vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me ) )
+                {
+                    if( nmakc && me.verarbeitet && nMak )
+                        me.verarbeitet = nMak( nmakParam, this, me );
+                    me.mx += pos.x, me.my += pos.y;
+                    return;
+                }
+            }
+            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
+            {
+                if( horizontalScrollBar->doMausMessage( rbr, gr.y - rbr - 15, gr.x - rbr * 2 - ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? 15 : 0 ), 15, me ) )
+                {
+                    if( nmakc && me.verarbeitet && nMak )
+                        me.verarbeitet = nMak( nmakParam, this, me );
+                    me.mx += pos.x, me.my += pos.y;
+                    return;
+                }
+            }
+            if( me.mx < gr.x - rbr - 15 )
+            {
+                if( schrift )
+                {
+                    schrift->setSchriftSize( 12 );
+                    bool shift = getTastenStand( T_Shift  );
+                    if( me.id == Framework::ME_PLinks )
+                    {
+                        int tbr = schrift->getTextBreite( script );
+                        int thi = schrift->getTextHeight( script );
+                        int scrollHi = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
+                        int scrollBr = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
+                        int xxx = me.mx - rbr + scrollBr;
+                        int yyy = me.my - rbr + scrollHi;
+                        int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
+                        int pos = schrift->textPos( script, xxx, yyy );
+                        if( pos != -1 )
+                        {
+                            if( shift )
+                                begF = pos;
+                            else
+                            {
+                                cPos = pos;
+                                begF = pos;
+                            }
+                            rend = 1;
+                            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
+                                updateVScroll( begF );
+                            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
+                                updateHScroll( begF );
+                        }
+                        mausKlick = 1;
+                    }
+                    if( me.id == ME_Bewegung && mausKlick )
+                    {
+                        int tbr = schrift->getTextBreite( script );
+                        int thi = schrift->getTextHeight( script );
+                        int scrollHi = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
+                        int scrollBr = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
+                        int xxx = me.mx - rbr + scrollBr;
+                        int yyy = me.my - rbr + scrollHi;
+                        int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
+                        int scrollHeight = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) * 15;
+                        int pos = schrift->textPos( script, xxx, yyy );
+                        if( pos != -1 )
+                        {
+                            if( begF != pos )
+                                rend = 1;
+                            begF = pos;
+                            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
+                                updateVScroll( begF );
+                            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
+                                updateHScroll( begF );
+                        }
+                    }
+                    if( me.id == ME_RLinks )
+                    {
+                        if( !shift )
+                        {
+                            int tbr = schrift->getTextBreite( script );
+                            int thi = schrift->getTextHeight( script );
+                            int scrollHi = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
+                            int scrollBr = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
+                            int xxx = me.mx - rbr + scrollBr;
+                            int yyy = me.my - rbr + scrollHi;
+                            int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
+                            int scrollHeight = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) * 15;
+                            int pos = schrift->textPos( script, xxx, yyy );
+                            if( pos != -1 )
+                            {
+                                begF = pos;
+                                if( vertikalScrollBar && hatStyle( Style::VScroll ) )
+                                    updateVScroll( begF );
+                                if( horizontalScrollBar && hatStyle( Style::HScroll ) )
+                                    updateHScroll( begF );
+                            }
+                            rend = 1;
+                        }
+                        mausKlick = 0;
+                    }
+                }
+            }
+        }
+        me.verarbeitet = 1;
+    }
+    if( nmakc && me.verarbeitet && nMak )
+        me.verarbeitet = nMak( nmakParam, this, me );
+    me.mx += pos.x, me.my += pos.y;
+}
+
+// Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
+//  te: Das Ereignis
+void Editor::doTastaturEreignis( TastaturEreignis &te )
+{
+    bool ntakc = !te.verarbeitet;
+    if( te.verarbeitet || hatStyleNicht( Style::Fokus ) )
+        return;
+    if( !tak )
+        return;
+    ++ref;
+    if( tak( takParam, this, te ) )
+    {
+        if( hatStyleNicht( Style::Erlaubt ) )
+        {
+            --ref;
+            if( !ref )
+                delete this;
+            return;
+        }
+        if( te.id == TE_Press )
+        {
+            bool shift = getTastenStand( T_Shift );
+            bool strg = getTastenStand( T_Strg );
+            switch( te.taste )
+            {
+            case T_Entf:
+                if( cPos != begF )
+                    script->remove( cPos, begF );
+                else
+                    script->remove( cPos, cPos + 1 );
+                begF = cPos;
+                rend = 1;
+                break;
+            case T_BackSpace:
+                if( cPos != begF )
+                {
+                    script->remove( cPos, begF );
+                    if( cPos > begF )
+                        cPos -= cPos - begF;
+                }
+                else
+                {
+                    script->remove( cPos - 1, cPos );
+                    --cPos;
+                }
+                begF = cPos;
+                rend = 1;
+                break;
+            case T_Enter:
+                if( cPos != begF )
+                {
+                    script->remove( begF, cPos );
+                    if( cPos > begF )
+                        cPos -= cPos - begF;
+                }
+                script->insert( cPos, '\n' );
+                ++cPos;
+                begF = cPos;
+                rend = 1;
+                break;
+            case T_Links:
+                if( shift )
+                {
+                    if( strg )
+                        begF = script->getLKick( begF );
+                    else
+                        --begF;
+                }
+                else
+                {
+                    if( strg )
+                        cPos = script->getLKick( cPos );
+                    else
+                        --cPos;
+                    begF = cPos;
+                }
+                rend = 1;
+                break;
+            case T_Oben:
+                if( shift )
+                {
+                    begF = script->getOKick( begF );
+                }
+                else
+                {
+                    cPos = script->getOKick( cPos );
+                    begF = cPos;
+                }
+                rend = 1;
+                break;
+            case T_Rechts:
+                if( shift )
+                {
+                    if( strg )
+                        begF = script->getRKick( begF );
+                    else
+                        ++begF;
+                }
+                else
+                {
+                    if( strg )
+                        cPos = script->getRKick( cPos );
+                    else
+                        ++cPos;
+                    begF = cPos;
+                }
+                rend = 1;
+                break;
+            case T_Unten:
+                if( shift )
+                {
+                    begF = script->getUKick( begF );
+                }
+                else
+                {
+                    cPos = script->getUKick( cPos );
+                    begF = cPos;
+                }
+                rend = 1;
+                break;
+            default:
+                if( strg && te.id == TE_Press )
+                {
+                    if( te.taste == 'c' || te.taste == 'C' )
+                    {
+                        if( begF != cPos )
+                        {
+                            int len = begF - cPos;
+                            if( len < 0 )
+                                len = -len;
+                            char *txt = new char[ len + 1 ];
+                            txt[ len ] = 0;
+                            int beg = begF < cPos ? begF : cPos;
+                            for( int i = beg; i < beg + len; ++i )
+                                txt[ i - beg ] = script->getText()[ i ];
+                            TextKopieren( txt );
+                            delete[] txt;
+                        }
+                        else
+                            TextKopieren( script->getText() );
+                    }
+                    if( te.taste == 'v' || te.taste == 'V' )
+                    {
+                        if( begF != cPos )
+                        {
+                            script->remove( begF, cPos );
+                            if( cPos > begF )
+                                cPos = begF;
+                        }
+                        char *txt = TextInsert();
+                        script->insert( cPos, txt );
+                        cPos += textLength( txt );
+                        begF = cPos;
+                        rend = 1;
+                    }
+                    break;
+                }
+                if( istSchreibbar( te.taste ) )
+                {
+                    if( begF != cPos )
+                    {
+                        script->remove( begF, cPos );
+                        if( cPos > begF )
+                            cPos = begF;
+                    }
+                    script->insert( cPos, (char)te.taste );
+                    ++cPos;
+                    begF = cPos;
+                    rend = 1;
+                }
+                break;
+            }
+        }
+        if( cPos < 0 )
+            cPos = 0;
+        if( cPos > script->getLength() )
+            cPos = script->getLength();
+        if( begF < 0 )
+            begF = 0;
+        if( begF > script->getLength() )
+            begF = script->getLength();
+        if( hatStyle( Style::VScroll ) )
+            updateVScroll( begF );
+        if( hatStyle( Style::HScroll ) )
+            updateHScroll( begF );
+        te.verarbeitet = 1;
+    }
+    lockZeichnung();
+    if( !--reloadCounter )
+    {
+        reloadCounter = 10;
+        parser->reload();
+    }
+    unlockZeichnung();
+    --ref;
+    if( ntakc && te.verarbeitet && nTak )
+        te.verarbeitet = nTak( ntakParam, this, te );
+    if( !ref )
+        delete this;
+}
+
+// Updated den Editor
+//  tickVal: Die vergangene Zeit in Sekunden, die seit dem Letzten Aufruf dieser Funktion verstrichen ist
+//  return: 1, wenn das Bild neu gezeichnet werden muss. 0 sonnst
+bool Editor::tick( double tickval )
+{
+    if( hatStyle( Style::Fokus ) )
+    {
+        if( tickVal < 0.5 && tickVal + tickval >= 0.5 )
+            rend = 1;
+        if( tickVal >= 0.5 && tickVal + tickval >= 1 )
+            rend = 1;
+        tickVal += tickval;
+        if( tickVal >= 1 )
+        {
+            lockZeichnung();
+            if( (reloadCounter -= 2 ) <= 0 )
+            {
+                reloadCounter = 10;
+                parser->reload();
+            }
+            unlockZeichnung();
+            tickVal -= 1;
+        }
+    }
+    return __super::tick( tickVal );
+}
+
+// Zeichnet den Editor nach rObj
+void Editor::render( Bild &rObj )
+{
+    if( hatStyleNicht( Style::Sichtbar ) )
+        return;
+    __super::render( rObj );
+    if( !script || !schrift )
+        return;
+    lockZeichnung();
+    if( !rObj.setDrawOptions( innenPosition, innenSize ) )
+    {
+        unlockZeichnung();
+        return;
+    }
+    schrift->setSchriftSize( 12 );
+    int tbr = schrift->getTextBreite( script );
+    int thi = schrift->getTextHeight( script );
+    int xxx = 0;
+    int yyy = 0;
+    int breite = innenSize.x;
+    int height = innenSize.y;
+    bool hs = horizontalScrollBar && hatStyle( Style::HScroll );
+    bool vs = vertikalScrollBar && hatStyle( Style::VScroll );
+    if( vs )
+        yyy -= vertikalScrollBar->getScroll();
+    if( hs )
+        xxx -= horizontalScrollBar->getScroll();
+    schrift->setDrawPosition( xxx, yyy );
+    parser->reset();
+    auto colorF = [ this, &rObj ]( int x, int y ) -> int
+    {
+        if( !parser )
+            return colors[ KSGScriptEditor::ColorType::NORMAL_TEXT ];
+        int uC =  -1;
+        int tC = colors[ parser->getNextColor( uC ) ];
+        if( uC >= 0 )
+            rObj.drawLinieH( x, y + 12, 12, colors[ uC ] );
+        return tC;
+    };
+    if( hatStyle( Style::Fokus ) && hatStyle( Style::Erlaubt ) )
+    {
+        if( tickVal <= 0.5 )
+            schrift->renderText( script, rObj, cPos, 0xFFFF5555, begF, 0xFF0000FF, colorF );
+        else
+            schrift->renderText( script, rObj, cPos, 0x00000000, begF, 0xFF0000FF, colorF );
+    }
+    else
+    {
+        schrift->renderText( script, rObj, colorF );
+    }
+    rObj.releaseDrawOptions();
+    unlockZeichnung();
+}
+
+// Setzt die Farbe eines Bestimmten Codetyps
+//  color: Die Farbe in 0xAARRGGBB Format
+//  cType: Der Codetyp, der die Farbe bekommen soll
+
+// Setzt die Farbe eines Bestimmten Codetyps
+//  color: Die Farbe in 0xAARRGGBB Format
+//  cType: Der Codetyp, der die Farbe bekommen soll
+void Editor::setTextColor( int color, ColorType cType )
+{
+    if( cType >= 0 && cType < ColorType::COLOR_ANZAHL )
+        colors[ cType ] = color;
+}
+
+// Reference Counting
+KSGScriptEditor *Editor::getThis()
+{
+    ref++;
+    return this;
+}
+
+KSGScriptEditor *Editor::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

ksgScript/Editor/Editor.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <Schrift.h>
+#include <Text.h>
+#include <MausEreignis.h>
+#include <TastaturEreignis.h>
+#include "../Include/KSGScript.h"
+
+using namespace Framework;
+
+namespace KSGScript
+{
+    class KSGScriptEditor;
+    class ColorParser;
+
+    class Editor : public KSGScriptEditor
+    {
+    private:
+        Schrift *schrift;
+        Text *script;
+        ColorParser *parser;
+        bool errorDetection;
+        bool warningDetection;
+        double tickVal;
+        int reloadCounter;
+        int cPos;
+        int begF;
+        int colors[ COLOR_ANZAHL ];
+        bool mausKlick;
+        int ref;
+
+        void updateHScroll( int pos );
+        void updateVScroll( int pos );
+
+    public:
+        // Konstructor
+        Editor();
+        // Destructor
+        ~Editor();
+        // Setzt die zu verwendende Schrift
+        //  s: Die Schrift
+        void setSchriftZ( Schrift *s ) override;
+        // Setzt den Text (das Script was verändert werden soll)
+        //  txt: Der Text
+        void setText( Framework::Text *txt ) override;
+        // Gibt den aktuellen Text zurück
+        Text *zText() const override;
+        // Schaltet die Fehlererkennung ein oder aus
+        //  on: 1, um die Fehlererkennung einzuschalten, 0 um sie auszuschalten
+        void setErrorDetection( bool on = 1 ) override;
+        // Schaltet die Warnungserkennung ein oder aus
+        //  on: 1, um die Warnungserkennung einzuschalten, 0 um sie auszuschalten
+        void setWarningDetection( bool on = 1 ) override;
+        // gibt 1 zurück, wenn die Fehlererkennung eingeschaltet ist
+        bool getErrorDetection() const override;
+        // gibt 1 zurück, wenn die Warnungserkennung eingeschaltet ist
+        bool getWarningDetection() const override;
+        // Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
+        //  me: Das Ereignis
+       void doMausEreignis( MausEreignis &me ) override;
+        // Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
+        //  te: Das Ereignis
+        void doTastaturEreignis( TastaturEreignis &te ) override;
+        // Updated den Editor
+        //  tickVal: Die vergangene Zeit in Sekunden, die seit dem Letzten Aufruf dieser Funktion verstrichen ist
+        //  return: 1, wenn das Bild neu gezeichnet werden muss. 0 sonnst
+        bool tick( double tickVal ) override;
+        // Zeichnet den Editor nach rObj
+        void render( Bild &rObj ) override;
+        // Setzt die Farbe eines Bestimmten Codetyps
+        //  color: Die Farbe in 0xAARRGGBB Format
+        //  cType: Der Codetyp, der die Farbe bekommen soll
+        void setTextColor( int color, ColorType cType ) override;
+        // Reference Counting
+        KSGScriptEditor *getThis() override;
+        KSGScriptEditor *release() override;
+    };
+}

ksgScript/Editor/Parser/ColorParser.cpp

@@ -0,0 +1,356 @@
+#include "ColorParser.h"
+
+using namespace KSGScript;
+
+const char *(ColorParser::keyword[]) = { "lesen", "var", "func", "Rückruf", "class", "public", "private", "if", "else", "return", "break", "continue", "for", "while" };
+const int ColorParser::keywordAnz = 14;
+const char *( ColorParser::type[] ) = { "void", "bool", "int", "double", "Array", "Thread", "Text", "Bild", "MausEreignis", "TastaturEreignis", "TextFeld", "Knopf", "Fenster", "BildZ", "Animation2DData", "Animation2D" };
+const int ColorParser::typeAnz = 16;
+
+// Konstructor
+//  zTxt: Der Text, der geparsed werden soll
+ColorParser::ColorParser( Text *zTxt )
+{
+    pfad = new Text( "" );
+    ref = 1;
+    txt = zTxt->getThis();
+    reset();
+    reload();
+}
+
+// Destructor
+ColorParser::~ColorParser()
+{
+    txt->release();
+}
+
+// behandelt einen Fehler
+void ColorParser::handleError( int begin, int ende )
+{
+    if( errorIgnore )
+        return;
+    Error err;
+    err.anfang = begin;
+    err.ende = ende;
+    error.add( err );
+}
+
+// Setzt den Parsevorgang zum Beginn zurück
+void ColorParser::reset()
+{
+    pos.pos = 0;
+    pos.inKeyword = 0;
+    pos.inTypename = 0;
+    pos.inParameter = 0;
+    pos.inInstanzVar = 0;
+    pos.inString = 0;
+    pos.inChar = 0;
+    pos.lastLehr = 1;
+    pos.lastTrenner = 1;
+}
+
+// Lädt das Script neu
+void ColorParser::reload()
+{
+    error.leeren();
+    for( auto i = abschnitt.getArray(); i.set; i++ )
+    {
+        if( i.var.zFunktion )
+            i.var.zFunktion->release();
+        if( i.var.zKlasse )
+            i.var.zKlasse->release();
+    }
+    abschnitt.leeren();
+    delete dat;
+    dat = new KSGSLeseScript();
+    d = new TextReader( txt->getThis() );
+    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", *pfad }, zObj );
+                    br = 1;
+                }
+                else
+                    dat->klassen.add( k );
+            }
+            break;
+        case 2: // funktion
+            if( 1 )
+            {
+                KSGSLeseFunktion *f = leseFunktion();
+                if( !f )
+                {
+                    //error( 6, { "Funktion", *pfad }, zObj );
+                    br = 1;
+                }
+                else
+                    dat->funktionen.add( f );
+            }
+            break;
+        case 3: // Variable
+            if( 1 )
+            {
+                KSGSLeseVariable *v = leseVariable();
+                if( !v )
+                {
+                    //error( 6, { "Variable", *pfad }, zObj );
+                    br = 1;
+                }
+                else
+                    dat->variablen.add( v );
+            }
+            break;
+        case 12: // lesen
+            if( 1 )
+            {
+                if( !leseBis( '(' ) )
+                {
+                    //error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d->setLPosition( d->getLPosition() + 1, 0 );
+                if( !leseBis( '"' ) )
+                {
+                    //error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d->setLPosition( d->getLPosition() + 1, 0 );
+                __int64 end = nextPosOf( '"', 0 );
+                if( end < 0 )
+                {
+                    //error( 6, { "Lade Anweisung", *pfad }, 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 = new Text( datei );
+                dPf->ersetzen( '\\', '/' );
+                if( dPf->getText()[ 0 ] == '/' )
+                    dPf->remove( 0 );
+                else
+                    dPf->insert( 0, wd->getText() );
+                delete[] datei;
+                if( !leseBis( ')' ) )
+                {
+                    //error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d->setLPosition( d->getLPosition() + 1, 0 );
+                Text *pf = new Text( pfad->getText() );
+                pfad->setText( dPf );
+                Reader *tmp = d;
+                if( !ladeDatei() )
+                {
+                    handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
+                    d = tmp;
+                    pfad->setText( pf );
+                    //error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d = tmp;
+                pfad->setText( pf );
+            }
+            break;
+        default: // Fehler
+            handleError( (int)d->getLPosition() - 1, (int)d->getLPosition() );
+            //error( 5, { *pfad, Text() += zeile }, zObj );
+            br = 1;
+            break;
+        }
+        if( id == -1 )
+            break;
+        if( br )
+        {
+            //ok = 0;
+            break;
+        }
+    }
+    d = ( (TextReader*)d )->release();
+}
+
+KSGSLeseKlasse *ColorParser::leseKlasse()
+{
+    Abschnitt abs;
+    abs.anfang = (int)d->getLPosition();
+    KSGSLeseKlasse *ret = __super::leseKlasse();
+    abs.ende = (int)d->getLPosition();
+    abs.zKlasse = ret;
+    abs.zFunktion = 0;
+    if( ret )
+        ret->ref++;
+    abschnitt.add( abs );
+    return ret;
+}
+
+KSGSLeseFunktion *ColorParser::leseFunktion()
+{
+    Abschnitt abs;
+    abs.anfang = (int)d->getLPosition();
+    KSGSLeseFunktion *ret = __super::leseFunktion();
+    abs.ende = (int)d->getLPosition();
+    abs.zKlasse = 0;
+    abs.zFunktion = ret;
+    if( ret )
+        ret->ref++;
+    abschnitt.add( abs );
+    return ret;
+}
+
+// Gibt den Farbtyp des nächsten Zeichens zurück
+KSGScriptEditor::ColorType ColorParser::getNextColor( int &underlineC )
+{
+    KSGScriptEditor::ColorType color = KSGScriptEditor::ColorType::NORMAL_TEXT;
+    int scriptL = txt->getLength();
+    char c = txt->getText()[ pos.pos++ ];
+    bool inString = pos.inChar || pos.inString;
+    if( c == '\'' && txt->getText()[ pos.pos - 2 ] != '\\' )
+        pos.inChar = !pos.inChar;
+    if( c == '"' && txt->getText()[ pos.pos - 2 ] != '\\' )
+        pos.inString = !pos.inString;
+    if( istLehr( c ) || istTrenner( c ) )
+    {
+        pos.inKeyword = 0;
+        pos.inTypename = 0;
+        pos.inInstanzVar = 0;
+        pos.inParameter = 0;
+    }
+    else if( !pos.inChar && !pos.inString )
+    {
+        if( !pos.inInstanzVar && !pos.inParameter && !pos.inKeyword && !pos.inTypename && pos.lastLehr )
+        {
+            for( int i = 0; i < keywordAnz; i++ )
+            {
+                int kl = textLength( keyword[ i ] );
+                pos.inKeyword = 1;
+                for( int j = 0; j < kl && j + pos.pos <= scriptL && pos.inKeyword; j++ )
+                    pos.inKeyword &= txt->getText()[ j + pos.pos - 1 ] == keyword[ i ][ j ];
+                if( pos.inKeyword && ( kl - 1 + pos.pos == scriptL || istTrenner( txt->getText()[ kl - 1 + pos.pos ] ) ) )
+                    break;
+                pos.inKeyword = 0;
+            }
+        }
+        if( !pos.inInstanzVar && !pos.inParameter && !pos.inKeyword && !pos.inTypename && pos.lastLehr )
+        {
+            for( int i = 0; i < typeAnz; i++ )
+            {
+                int tl = textLength( type[ i ] );
+                pos.inTypename = 1;
+                for( int j = 0; j < tl && j + pos.pos <= scriptL && pos.inTypename; j++ )
+                    pos.inTypename &= txt->getText()[ j + pos.pos - 1 ] == type[ i ][ j ];
+                if( pos.inTypename && ( tl - 1 + pos.pos == scriptL || istTrenner( txt->getText()[ tl - 1 + pos.pos ] ) ) )
+                    break;
+                pos.inTypename = 0;
+            }
+            if( !pos.inTypename && dat )
+            {
+                int anz = dat->klassen.getEintragAnzahl();
+                for( int i = 0; i < anz; i++ )
+                {
+                    int tl = dat->klassen.get( i )->name.getLength();
+                    pos.inTypename = 1;
+                    for( int j = 0; j < tl && j + pos.pos <= scriptL && pos.inTypename; j++ )
+                        pos.inTypename &= txt->getText()[ j + pos.pos - 1 ] == dat->klassen.get( i )->name.getText()[ j ];
+                    if( pos.inTypename && ( tl - 1 + pos.pos == scriptL || istTrenner( txt->getText()[ tl - 1 + pos.pos ] ) ) )
+                        break;
+                    pos.inTypename = 0;
+                }
+            }
+        }
+        if( !pos.inInstanzVar && !pos.inParameter && !pos.inKeyword && !pos.inTypename && pos.lastLehr )
+        {
+            for( auto i = abschnitt.getArray(); i.set; i++ )
+            {
+                if( i.var.anfang <= pos.pos - 1 && i.var.ende >= pos.pos - 1 )
+                {
+                    if( i.var.zFunktion )
+                    {
+                        int anz = i.var.zFunktion->parameter.getEintragAnzahl();
+                        for( int j = 0; j < anz; j++ )
+                        {
+                            int nl = i.var.zFunktion->parameter.get( j )->name.getLength();
+                            pos.inParameter = 1;
+                            for( int k = 0; k < nl && k + pos.pos <= scriptL && pos.inParameter; k++ )
+                                pos.inParameter &= txt->getText()[ k + pos.pos - 1 ] == i.var.zFunktion->parameter.get( j )->name.getText()[ k ];
+                            if( pos.inParameter && ( nl - 1 + pos.pos == scriptL || istTrenner( txt->getText()[ nl - 1 + pos.pos ] ) ) )
+                                break;
+                            pos.inParameter = 0;
+                        }
+                    }
+                }
+            }
+        }
+        if( !pos.inInstanzVar && !pos.inParameter && !pos.inKeyword && !pos.inTypename && pos.lastLehr )
+        {
+            for( auto i = abschnitt.getArray(); i.set; i++ )
+            {
+                if( i.var.anfang <= pos.pos - 1 && i.var.ende >= pos.pos - 1 )
+                {
+                    if( i.var.zKlasse )
+                    {
+                        int anz = i.var.zKlasse->variablen.getEintragAnzahl();
+                        for( int j = 0; j < anz; j++ )
+                        {
+                            int nl = i.var.zKlasse->variablen.get( j )->name.getLength();
+                            pos.inInstanzVar = 1;
+                            for( int k = 0; k < nl && k + pos.pos <= scriptL && pos.inInstanzVar; k++ )
+                                pos.inInstanzVar &= txt->getText()[ k + pos.pos - 1 ] == i.var.zKlasse->variablen.get( j )->name.getText()[ k ];
+                            if( pos.inInstanzVar && ( nl - 1 + pos.pos == scriptL || istTrenner( txt->getText()[ nl - 1 + pos.pos ] ) ) )
+                                break;
+                            pos.inInstanzVar = 0;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if( pos.inKeyword )
+        color = KSGScriptEditor::ColorType::KEYWORD;
+    if( pos.inTypename )
+        color = KSGScriptEditor::ColorType::TYPENAME;
+    if( pos.inParameter )
+        color = KSGScriptEditor::ColorType::PARAMETER_VARIABLE;
+    if( pos.inInstanzVar )
+        color = KSGScriptEditor::ColorType::INSTANCE_VARIABLE;
+    if( pos.inChar || pos.inString || inString )
+        color = KSGScriptEditor::ColorType::STRING;
+    for( auto i = error.getArray(); i.set; i++ )
+    {
+        if( i.var.anfang <= pos.pos && i.var.ende >= pos.pos )
+            underlineC = KSGScriptEditor::ColorType::ERROR_UNDERLINE;
+    }
+    pos.lastLehr = istLehr( c );
+    pos.lastTrenner = istTrenner( c );
+    return color;
+}
+
+// Reference Counting
+ColorParser *ColorParser::getThis()
+{
+    ref++;
+    return this;
+}
+
+ColorParser *ColorParser::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

ksgScript/Editor/Parser/ColorParser.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "../../Leser/KSGSLeser.h"
+#include "../../Include/KSGScript.h"
+
+using namespace Framework;
+
+namespace KSGScript
+{
+    class ColorParser : private KSGSLeser
+    {
+    private:
+        struct Position
+        {
+            int pos;
+            bool inKeyword;
+            bool inTypename;
+            bool inInstanzVar;
+            bool inParameter;
+            bool inString;
+            bool inChar;
+            bool lastLehr;
+            bool lastTrenner;
+        };
+        struct Abschnitt
+        {
+            int anfang;
+            int ende;
+            KSGSLeseKlasse *zKlasse;
+            KSGSLeseFunktion *zFunktion;
+        };
+        struct Error
+        {
+            int anfang;
+            int ende;
+        };
+        Array< Abschnitt > abschnitt;
+        Array< Error > error;
+        int ref;
+        Text *txt;
+        Text *wd;
+        Position pos;
+        static const char *keyword[];
+        static const int keywordAnz;
+        static const char *type[];
+        static const int typeAnz;
+
+    public:
+        // Konstructor
+        //  zTxt: Der Text, der geparsed werden soll
+        ColorParser( Text *zTxt );
+        // Destructor
+        ~ColorParser();
+        // behandelt einen Fehler
+        void handleError( int begin, int ende ) override;
+        // Setzt den Parsevorgang zum Beginn zurück
+        void reset();
+        // Lädt das Script neu
+        void reload();
+        KSGSLeseKlasse *leseKlasse() override;
+        KSGSLeseFunktion *leseFunktion() override;
+        // Gibt den Farbtyp des nächsten Zeichens zurück
+        KSGScriptEditor::ColorType getNextColor( int &underlineC );
+        // Reference Counting
+        ColorParser *getThis();
+        ColorParser *release();
+    };
+}

ksgScript/Error/Error.h

@@ -2,7 +2,7 @@
 
 namespace KSGScript
 {
-    class KSGScriptObj; // KSGScriptObj.h
+    class KSGScriptObj; // KSGScriptO.h
 
 #define KSGS_WARNING_CreateVar 0
 #define KSGS_WARNING_CreateVarTyp 1

ksgScript/Funktionen/KSGSRückruf.cpp

@@ -51,7 +51,7 @@ KSGSR
 }
 
 // nicht constant
-KSGSFunktionInstanz *KSGSRückrufFunktion::erstellInstanz( KSGScriptObj *obj, KSGSKlasseInstanz *klasse, RCArray< KSGSVariable > *params )
+KSGSFunktionInstanz *KSGSRückrufFunktion::erstellInstanz( KSGScriptObj *obj, KSGSVariable *klasse, RCArray< KSGSVariable > *params )
 {
 	KSGSRückrufInstanz *inst = new KSGSRückrufInstanz( obj );
 	if( params )

ksgScript/Funktionen/KSGSRückruf.h

@@ -2,6 +2,8 @@
 
 namespace KSGScript
 {
+    class KSGScriptObj;
+
 	class KSGSRückrufInstanz : public KSGSFunktionInstanz
 	{
 	private:
@@ -13,8 +15,8 @@ namespace KSGScript
 		// Destruktor
 		__declspec( dllexport ) ~KSGSRückrufInstanz();
 		// nicht constant
-		__declspec( dllexport ) virtual void setParameter( Array< KSGSVariableDef* > *zDef, RCArray< KSGSVariable > *vars );
-		__declspec( dllexport ) virtual KSGSVariable *startFunktion();
+		__declspec( dllexport ) virtual void setParameter( Array< KSGSVariableDef* > *zDef, RCArray< KSGSVariable > *vars ) override;
+		__declspec( dllexport ) virtual KSGSVariable *startFunktion() override;
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSFunktionInstanz *release();
 	};
@@ -25,7 +27,7 @@ namespace KSGScript
 		// Konstruktor
 		__declspec( dllexport ) KSGSRückrufFunktion();
 		// nicht constant
-		__declspec( dllexport ) virtual KSGSFunktionInstanz *erstellInstanz( KSGScriptObj *obj, KSGSKlasseInstanz *klasse, RCArray< KSGSVariable > *params );
+		__declspec( dllexport ) virtual KSGSFunktionInstanz *erstellInstanz( KSGScriptObj *obj, KSGSVariable *klasse, RCArray< KSGSVariable > *params );
 		// Reference Counting
 		__declspec( dllexport ) virtual KSGSFunktion *release();
 	};

ksgScript/Include/KSGScript.h

@@ -1,5 +1,4 @@
-#ifndef KSGScriptObj_H
-#define KSGScriptObj_H
+#pragma once
 
 #include <Array.h>
 #include <Text.h>
@@ -22,13 +21,13 @@ namespace Framework
 
 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.
@@ -61,6 +60,7 @@ namespace KSGScript
 		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;
 		// Reference Counting
 		virtual KSGSVariable *getThis() = 0;
 		virtual KSGSVariable *release() = 0;
@@ -76,8 +76,8 @@ namespace KSGScript
 	{
 	public:
 		// nicht constant
-		virtual void lock();
-		virtual void unlock();
+		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;
@@ -112,13 +112,55 @@ namespace KSGScript
 		virtual KSGScriptObj *getThis() = 0;
 		virtual KSGScriptObj *release() = 0;
 	};
+
+    // Ein Textfeld, das eine Entwicklungsumgebung für die KSG-Script Sprache darstellt
+    class KSGScriptEditor : virtual public Framework::ZeichnungHintergrund
+    {
+    public:
+        enum ColorType
+        {
+            KEYWORD,
+            TYPENAME,
+            PARAMETER_VARIABLE,
+            INSTANCE_VARIABLE,
+            STRING,
+            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 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;
+        // Reference Counting
+        virtual KSGScriptEditor *getThis() = 0;
+        virtual KSGScriptEditor *release() = 0;
+    };
 	// DLL Einstieg
+    typedef KSGScriptEditor *( *KSGSGetEditor )( );
 	typedef KSGScriptObj *( *KSGSGetZeichnung )( );
 	typedef KSGSVariable *( *KSGSGetVariable )( KSGScriptObj *zObj, KSGSVariableDef *def );
 	typedef void ( *KSGSSetBild )( KSGSVariable *zBv, Framework::Bild *b );
 }
 #define KSGS_START_FUNKTION "GetNewKSGScriptObj"
+#define KSGS_EDITOR_FUNKTION "GetNewKSGEditorObj"
 #define KSGS_VARIABLE_FUNKTION "GetNewKSGSVariable"
-#define KSGS_SET_BILD_FUNKTION "SetKSGSBildVariable"
-
-#endif
+#define KSGS_SET_BILD_FUNKTION "SetKSGSBildVariable"

ksgScript/Klassen/KSGSTyp.h

@@ -1,5 +1,4 @@
-#ifndef KSGSTyp_H
-#define KSGSTyp_H
+#pragma once
 
 // Klassen
 // Entspricht der Definitionsreihenfolge im Konstruktor der KSGSCompKlassTable Klasse aus KSGSCompile.h
@@ -57,6 +56,4 @@
 #define KSGS_O_NACHLINKS      26
 #define KSGS_O_NACHRECHTS     27
 
-#define KSGS_O_TYP_MAX        27
-
-#endif
+#define KSGS_O_TYP_MAX        27

ksgScript/Leser/KSGSLeser.cpp

@@ -9,1109 +9,1173 @@
 
 using namespace KSGScript;
 
-
 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 )
 {
-	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 )
 {
-	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_GRÖßERGLEICH;
-	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_GRÖßER;
-	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_GRÖßERGLEICH;
+    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_GRÖßER;
+    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 *län )
 {
-	*län = 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( ">>" );
-	*län = 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( "~" );
-	*län = 0;
-	return -1;
+    *län = 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( ">>" );
+    *län = 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( "~" );
+    *län = 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;
 }
 
 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;
 }
 
 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++ )
-		delete funktionen.get( j );
+    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++ )
-		delete funktionen.get( i );
-	anz = klassen.getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-		delete klassen.get( i );
+    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( const char *pfad, KSGScriptObj *zObj )
+KSGSLeser::KSGSLeser( const char *pfad, KSGScriptO *zObj )
+    : KSGSLeser()
 {
-	this->zObj = zObj;
-	d = 0;
-	dat = 0;
-	this->pfad = new Text( pfad );
-	zeile = 0;
-	mainFuncId = -1;
-	mausFuncId = -1;
-	tastaturFuncId = -1;
-	tickFuncId = -1;
-	renderFuncId = -1;
-	ref = 1;
+    this->zObj = zObj;
+    this->pfad = new Text( pfad );
 }
 
 // Destruktor
 KSGSLeser::~KSGSLeser()
 {
-	delete dat;
-	pfad->release();
+    delete dat;
+    if( pfad )
+        pfad->release();
 }
 
-// privat
+// protected
+KSGSLeser::KSGSLeser()
+{
+    errorIgnore = 0;
+    this->zObj = 0;
+    d = 0;
+    dat = 0;
+    this->pfad = 0;
+    zeile = 0;
+    mainFuncId = -1;
+    mausFuncId = -1;
+    tastaturFuncId = -1;
+    tickFuncId = -1;
+    renderFuncId = -1;
+    ref = 1;
+}
+
+void KSGSLeser::handleError( int beginn, int ende )
+{}
+
 // Script Laden
 bool KSGSLeser::ladeDatei()
 {
-	bool ok = 1;
-	d = new Datei();
-	d->setDatei( *pfad );
-	if( !d->open( Datei::Style::lesen ) )
-	{
-		d->release();
-		error( 4, { *pfad }, zObj );
-		return 0;
-	}
-	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", *pfad }, zObj );
-					br = 1;
-				}
-				else
-					dat->klassen.add( k );
-			}
-			break;
-		case 2: // funktion
-			if( 1 )
-			{
-				KSGSLeseFunktion *f = leseFunktion();
-				if( !f )
-				{
-					error( 6, { "Funktion", *pfad }, zObj );
-					br = 1;
-				}
-				else
-					dat->funktionen.add( f );
-			}
-			break;
-		case 3: // Variable
-			if( 1 )
-			{
-				KSGSLeseVariable *v = leseVariable();
-				if( !v )
-				{
-					error( 6, { "Variable", *pfad }, zObj );
-					br = 1;
-				}
-				else
-					dat->variablen.add( v );
-			}
-			break;
-		case 12: // lesen
-			if( 1 )
-			{
-				if( !leseBis( '(' ) )
-				{
-					error( 6, { "Lade Anweisung", *pfad }, zObj );
-					br = 1;
-					break;
-				}
-				d->setLPosition( d->getLPosition() + 1, 0 );
-				if( !leseBis( '"' ) )
-				{
-					error( 6, { "Lade Anweisung", *pfad }, zObj );
-					br = 1;
-					break;
-				}
-				d->setLPosition( d->getLPosition() + 1, 0 );
-				__int64 end = nextPosOf( '"', 0 );
-				if( end < 0 )
-				{
-					error( 6, { "Lade Anweisung", *pfad }, 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", *pfad }, zObj );
-					br = 1;
-					break;
-				}
-				d->setLPosition( d->getLPosition() + 1, 0 );
-				Text *pf = new Text( pfad->getText() );
-				pfad->setText( dPf );
-				Datei *tmp = d;
-				if( !ladeDatei() )
-				{
-					d = tmp;
-					pfad->setText( pf );
-					error( 6, { "Lade Anweisung", *pfad }, zObj );
-					br = 1;
-					break;
-				}
-				d = tmp;
-				pfad->setText( pf );
-			}
-			break;
-		default: // Fehler
-			error( 5, { *pfad, Text() += zeile }, zObj );
-			br = 1;
-			break;
-		}
-		if( id == -1 )
-			break;
-		if( br )
-		{
-			ok = 0;
-			break;
-		}
-	}
-	d->close();
-	d = d->release();
-	return ok;
+    bool ok = 1;
+    Datei *datei = new Datei();
+    datei->setDatei( *pfad );
+    if( !datei->open( Datei::Style::lesen ) )
+    {
+        datei->release();
+        error( 4, { *pfad }, zObj );
+        return 0;
+    }
+    d = datei;
+    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", *pfad }, zObj );
+                    br = 1;
+                }
+                else
+                    dat->klassen.add( k );
+            }
+            break;
+        case 2: // funktion
+            if( 1 )
+            {
+                KSGSLeseFunktion *f = leseFunktion();
+                if( !f )
+                {
+                    error( 6, { "Funktion", *pfad }, zObj );
+                    br = 1;
+                }
+                else
+                    dat->funktionen.add( f );
+            }
+            break;
+        case 3: // Variable
+            if( 1 )
+            {
+                KSGSLeseVariable *v = leseVariable();
+                if( !v )
+                {
+                    error( 6, { "Variable", *pfad }, zObj );
+                    br = 1;
+                }
+                else
+                    dat->variablen.add( v );
+            }
+            break;
+        case 12: // lesen
+            if( 1 )
+            {
+                if( !leseBis( '(' ) )
+                {
+                    error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d->setLPosition( d->getLPosition() + 1, 0 );
+                if( !leseBis( '"' ) )
+                {
+                    error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d->setLPosition( d->getLPosition() + 1, 0 );
+                __int64 end = nextPosOf( '"', 0 );
+                if( end < 0 )
+                {
+                    error( 6, { "Lade Anweisung", *pfad }, 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", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d->setLPosition( d->getLPosition() + 1, 0 );
+                Text *pf = new Text( pfad->getText() );
+                pfad->setText( dPf );
+                Reader *tmp = d;
+                if( !ladeDatei() )
+                {
+                    d = tmp;
+                    pfad->setText( pf );
+                    error( 6, { "Lade Anweisung", *pfad }, zObj );
+                    br = 1;
+                    break;
+                }
+                d = tmp;
+                pfad->setText( pf );
+            }
+            break;
+        default: // Fehler
+            error( 5, { *pfad, Text() += zeile }, zObj );
+            br = 1;
+            break;
+        }
+        if( id == -1 )
+            break;
+        if( br )
+        {
+            ok = 0;
+            break;
+        }
+    }
+    datei->close();
+    d = datei->release();
+    return ok;
 }
 
 bool KSGSLeser::leseBis( char c )
 {
-	__int64 pos = d->getLPosition();
-	int tmpZ = zeile;
-	char byte = 0;
-	bool kommentar = 0;
-	bool slash = 0;
-	bool gefunden = 0;
-	while( !d->istEnde() )
-	{
-		d->lese( &byte, 1 );
-		if( byte == '\n' )
-		{
-			zeile++;
-			kommentar = 0;
-			continue;
-		}
-		if( byte == '#' )
-		{
-			kommentar = 1;
-			continue;
-		}
-		if( byte == '/' )
-		{
-			if( slash )
-			{
-				kommentar = 1;
-				slash = 0;
-			}
-			else
-				slash = 1;
-			continue;
-		}
-		else
-			slash = 0;
-		if( byte == c && !kommentar )
-		{
-			gefunden = 1;
-			break;
-		}
-	}
-	if( d->istEnde() && !gefunden )
-	{
-		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;
+    bool slash = 0;
+    bool gefunden = 0;
+    while( !d->istEnde() )
+    {
+        d->lese( &byte, 1 );
+        if( byte == '\n' )
+        {
+            zeile++;
+            kommentar = 0;
+            continue;
+        }
+        if( byte == '#' )
+        {
+            kommentar = 1;
+            continue;
+        }
+        if( byte == '/' )
+        {
+            if( slash )
+            {
+                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 pos = d->getLPosition();
-	char byte = 0;
-	bool kommentar = 0;
-	bool slash = 0;
-	int count = 0;
-	bool gefunden = 0;
-	while( !d->istEnde() )
-	{
-		d->lese( &byte, 1 );
-		if( byte == '\n' )
-		{
-			kommentar = 0;
-			continue;
-		}
-		if( byte == '#' )
-		{
-			kommentar = 1;
-			continue;
-		}
-		if( byte == '/' )
-		{
-			if( slash )
-			{
-				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 )
-	{
-		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;
+    bool slash = 0;
+    int count = 0;
+    bool gefunden = 0;
+    while( !d->istEnde() )
+    {
+        d->lese( &byte, 1 );
+        if( byte == '\n' )
+        {
+            kommentar = 0;
+            continue;
+        }
+        if( byte == '#' )
+        {
+            kommentar = 1;
+            continue;
+        }
+        if( byte == '/' )
+        {
+            if( slash )
+            {
+                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;
-	bool slash = 0;
-	bool gefunden = 0;
-	while( !d->istEnde() )
-	{
-		d->lese( &c, 1 );
-		if( c == '\n' )
-		{
-			zeile++;
-			kommentar = 0;
-			continue;
-		}
-		if( c == '#' )
-		{
-			kommentar = 1;
-			continue;
-		}
-		if( c == '/' )
-		{
-			if( slash )
-			{
-				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;
+    bool slash = 0;
+    bool gefunden = 0;
+    while( !d->istEnde() )
+    {
+        d->lese( &c, 1 );
+        if( c == '\n' )
+        {
+            zeile++;
+            kommentar = 0;
+            continue;
+        }
+        if( c == '#' )
+        {
+            kommentar = 1;
+            continue;
+        }
+        if( c == '/' )
+        {
+            if( slash )
+            {
+                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 )
 {
-	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 )
 {
-	return c == ' ' || c == '\n' || c == '\r' || c == '\t';
+    return c == ' ' || c == '\n' || c == '\r' || c == '\t';
 }
 
 KSGSLeseKlasse *KSGSLeser::leseKlasse()
 {
-	KSGSLeseKlasse *ret = new KSGSLeseKlasse();
-	ret->debug.datei.setText( *pfad );
-	ret->debug.zeile = zeile;
-	d->setLPosition( d->getLPosition() + 5, 0 ); // 'class' überspringen
-	if( !leseBisText() ) // Bis zum beginn des Klassennamens lesen
-	{
-		delete ret;
-		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
-	{
-		delete ret;
-		return 0;
-	}
-	d->setLPosition( d->getLPosition() + 1, 0 );
-	bool sichtbar = 0;
-	__int64 ende = nextPosOf( '}', '{' ); // Ende der Klasse
-	if( ende < 0 )
-	{
-		delete ret;
-		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 )
-				{
-					delete ret;
-					return 0;
-				}
-				ret->funktionen.add( f );
-				ret->fSichtbar.add( sichtbar );
-			}
-			break;
-		case 3: // Variable
-			if( 1 )
-			{
-				KSGSLeseVariable *v = leseVariable();
-				if( !v )
-				{
-					delete ret;
-					return 0;
-				}
-				ret->variablen.add( v );
-				ret->vSichtbar.add( sichtbar );
-			}
-			break;
-		case 4: // public
-			sichtbar = 1;
-			d->setLPosition( d->getLPosition() + 6, 0 );
-			if( !leseBis( ':' ) )
-			{
-				delete ret;
-				return 0;
-			}
-			d->setLPosition( d->getLPosition() + 1, 0 );
-			break;
-		case 5: // private
-			sichtbar = 0;
-			d->setLPosition( d->getLPosition() + 7, 0 );
-			if( !leseBis( ':' ) )
-			{
-				delete ret;
-				return 0;
-			}
-			d->setLPosition( d->getLPosition() + 1, 0 );
-			break;
-		default:
-			delete ret;
-			return 0;
-		}
-	}
-	if( d->getLPosition() > ende )
-	{
-		delete ret;
-		return 0;
-	}
-	d->setLPosition( ende + 1, 0 );
-	if( !leseBis( ';' ) ) // ';' Nach einer Klasse überlesen
-	{
-		delete ret;
-		return 0;
-	}
-	d->setLPosition( d->getLPosition() + 1, 0 );
-	return ret;
+    KSGSLeseKlasse *ret = new KSGSLeseKlasse();
+    ret->debug.datei.setText( *pfad );
+    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 *ret = new KSGSLeseFunktion();
-	ret->debug.datei.setText( *pfad );
-	ret->debug.zeile = zeile;
-	d->setLPosition( d->getLPosition() + 4, 0 ); // 'func' überspringen
-	if( !leseBisText() )
-	{
-		delete ret;
-		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() )
-	{
-		delete ret;
-		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
-	{
-		delete ret;
-		return 0;
-	}
-	d->setLPosition( d->getLPosition() + 1, 0 );
-	__int64 paramEnde = nextPosOf( ')', '(' );
-	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
-	{
-		delete ret;
-		return 0;
-	}
-	d->setLPosition( d->getLPosition() + 1, 0 );
-	__int64 funkEnde = nextPosOf( '}', '{' ); // Ende der Funktion
-	while( d->getLPosition() < funkEnde )
-	{
-		KSGSLeseBefehl *bef = leseBefehl(); // Befehle einlesen
-		if( !bef )
-			break;
-		else
-			ret->befehle.add( bef );
-		if( !leseBisText() )
-		{
-			delete ret;
-			return 0;
-		}
-	}
-	d->setLPosition( funkEnde + 1, 0 ); // '}' am ende der Funktion überlesen
-	return ret;
+    KSGSLeseFunktion *ret = new KSGSLeseFunktion();
+    ret->debug.datei.setText( *pfad );
+    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 *ret = new KSGSLeseVariable();
-	ret->debug.datei.setText( *pfad );
-	ret->debug.zeile = zeile;
-	if( !param )
-		d->setLPosition( d->getLPosition() + 3, 0 ); // 'var' überspringen
-	__int64 endPos = 0;
-	if( param )
-		endPos = nextPosOf( ')', 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() )
-	{
-		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( param )
-	{
-		__int64 tmp = nextPosOf( ',', 0 );
-		if( tmp >= 0 && tmp < endPos )
-			ende = tmp;
-		else
-			ende = endPos;
-	}
-	__int64 gleich = nextPosOf( '=', 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 )
-	{
-		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( *pfad );
+    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()
 {
-	__int64 fEnde = nextPosOf( '}', '{' );
-	if( fEnde < 0 )
-		return 0;
-	int typ = leseNext();
-	if( typ < 0 )
-		return 0;
-	KSGSLeseBefehl *ret = new KSGSLeseBefehl();
-	ret->debug.datei.setText( *pfad );
-	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 län = (int)( endPos - d->getLPosition() );
-			if( län )
-			{
-				char *txt = new char[ län + 1 ];
-				txt[ län ] = 0;
-				d->lese( txt, län );
-				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 län = (int)( endPos - d->getLPosition() );
-			if( län )
-			{
-				char *txt = new char[ län + 1 ];
-				txt[ län ] = 0;
-				d->lese( txt, län );
-				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() )
-			{
-				delete ret;
-				return 0;
-			}
-			char *el = new char[ 5 ];
+    __int64 fEnde = nextPosOf( '}', '{' );
+    if( fEnde < 0 )
+        return 0;
+    int typ = leseNext();
+    if( typ < 0 )
+        return 0;
+    KSGSLeseBefehl *ret = new KSGSLeseBefehl();
+    ret->debug.datei.setText( *pfad );
+    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 län = (int)( endPos - d->getLPosition() );
+            if( län )
+            {
+                char *txt = new char[ län + 1 ];
+                txt[ län ] = 0;
+                d->lese( txt, län );
+                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 län = (int)( endPos - d->getLPosition() );
+            if( län )
+            {
+                char *txt = new char[ län + 1 ];
+                txt[ län ] = 0;
+                d->lese( txt, län );
+                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 län = (int)( endPos - d->getLPosition() );
-			if( län )
-			{
-				char *txt = new char[ län + 1 ];
-				txt[ län ] = 0;
-				d->lese( txt, län );
-				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 län = (int)( endPos - d->getLPosition() );
-			if( län )
-			{
-				char *txt = new char[ län + 1 ];
-				txt[ län ] = 0;
-				d->lese( txt, län );
-				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;
-	}
-	if( d->getLPosition() > fEnde )
-	{
-		delete ret;
-		return 0;
-	}
-	ret->befehl.ersetzen( "->", "." );
-	return ret;
+            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 län = (int)( endPos - d->getLPosition() );
+            if( län )
+            {
+                char *txt = new char[ län + 1 ];
+                txt[ län ] = 0;
+                d->lese( txt, län );
+                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 län = (int)( endPos - d->getLPosition() );
+            if( län )
+            {
+                char *txt = new char[ län + 1 ];
+                txt[ län ] = 0;
+                d->lese( txt, län );
+                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 )
 {
-	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++ )
-	{
+    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( !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 )
 {
-	KSGSCompileFunktion *f = new KSGSCompileFunktion( zKT->get( (char*)zLF->typ )->id, s, {} );
-	int anz = zLF->parameter.getEintragAnzahl();
+    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 );
@@ -1123,319 +1187,319 @@ bool KSGSLeser::compileFunktion( KSGSLeseFunktion *zLF, KSGSCompKlassTable *zKT,
             return 0;
         }
     }
-	if( !zFT->addFunktion( zLF->name, f ) )
-	{
-		error( 8, { zLF->debug.datei, Text() += zLF->debug.zeile, zLF->name }, zObj );
-		return 0;
-	}
-	return 1;
+    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 )
 {
-	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( (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;
 }
 
 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( (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;
 }
 
 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 );
+    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;
+        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 *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 = 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 = 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 )
 {
-	// 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++ )
-	{
+    // 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 KSGSRückrufFunktion() );
-	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;
+        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 KSGSRückrufFunktion() );
+    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;
 }
 
 // Reference Counting
 KSGSLeser *KSGSLeser::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 KSGSLeser *KSGSLeser::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

ksgScript/Leser/KSGSLeser.h

@@ -3,13 +3,13 @@
 
 #include <Text.h>
 #include <Array.h>
-#include <Datei.h>
+#include <Reader.h>
 
 using namespace Framework;
 
 namespace KSGScript
 {
-	class KSGScriptObj;
+	class KSGScriptO;
 	class KSGSKlasse;
 	class KSGSFunktion;
 	struct KSGSVariableDef;
@@ -50,23 +50,27 @@ namespace KSGScript
 
 	struct KSGSLeseFunktion
 	{
+        int ref = 1;
 		Text name;
 		Text typ;
 		Array< KSGSLeseVariable* > parameter;
 		Array< KSGSLeseBefehl* > befehle;
 		KSGSLeseDebug debug;
+        void release();
 		// Destruktor
 		__declspec( dllexport ) ~KSGSLeseFunktion();
 	};
 
 	struct KSGSLeseKlasse
 	{
+        int ref = 1;
 		Text name;
 		Array< KSGSLeseVariable* > variablen;
 		Array< bool > vSichtbar;
 		Array< KSGSLeseFunktion* > funktionen;
 		Array< bool > fSichtbar;
 		KSGSLeseDebug debug;
+        void release();
 		// Destruktor
 		__declspec( dllexport ) ~KSGSLeseKlasse();
 	};
@@ -83,19 +87,24 @@ namespace KSGScript
 	class KSGSLeser
 	{
 	private:
-		KSGScriptObj *zObj;
-		KSGSLeseScript *dat;
-		Datei *d;
-		Text *pfad;
-		int zeile;
+		KSGScriptO *zObj;
 		int mainFuncId;
 		int mausFuncId;
 		int tastaturFuncId;
 		int tickFuncId;
 		int renderFuncId;
 		int ref;
-		// privat
+
+    protected:
+        bool errorIgnore;
+        Text *pfad;
+        KSGSLeseScript *dat;
+        int zeile;
+        Reader *d;
+
 		// Script Laden
+        KSGSLeser();
+        virtual void handleError( int begin, int ende );
 		__declspec( dllexport ) bool ladeDatei();
 		__declspec( dllexport ) bool leseBis( char c );
 		__declspec( dllexport ) __int64 nextPosOf( char c, char c2 );
@@ -103,8 +112,8 @@ namespace KSGScript
 		__declspec( dllexport ) int leseNext();
 		__declspec( dllexport ) bool istTrenner( char c );
 		__declspec( dllexport ) bool istLehr( char c );
-		__declspec( dllexport ) KSGSLeseKlasse *leseKlasse();
-		__declspec( dllexport ) KSGSLeseFunktion *leseFunktion();
+		__declspec( dllexport ) virtual KSGSLeseKlasse *leseKlasse();
+		__declspec( dllexport ) virtual KSGSLeseFunktion *leseFunktion();
 		__declspec( dllexport ) KSGSLeseVariable *leseVariable( bool param = 0 );
 		__declspec( dllexport ) KSGSLeseBefehl *leseBefehl();
 		// Script Compilieren
@@ -117,7 +126,7 @@ namespace KSGScript
 
 	public:
 		// Konstruktor
-		__declspec( dllexport ) KSGSLeser( const char *pfad, KSGScriptObj *zObj );
+		__declspec( dllexport ) KSGSLeser( const char *pfad, KSGScriptO *zObj );
 		// Destruktor
 		__declspec( dllexport ) ~KSGSLeser();
 		// nicht constant

ksgScript/Main/Einstieg.cpp

@@ -1,6 +1,6 @@
 #include "KSGScriptObj.h"
+#include "../Editor/Editor.h"
 #include "../Befehl/KSGSKlasse.h"
-#include "../Klassen/KSGSTyp.h"
 #include "../Klassen/KSGSBild.h"
 
 using namespace KSGScript;
@@ -9,12 +9,17 @@ extern "C"
 {
 	__declspec( dllexport ) KSGScriptObj *GetNewKSGScriptObj()
 	{
-		return new KSGScriptObj();
+		return new KSGScriptO();
 	}
 
+    __declspec( dllexport ) KSGScriptEditor *GetNewKSGEditorObj()
+    {
+        return new Editor();
+    }
+
 	__declspec( dllexport ) KSGSVariable *GetNewKSGSVariable( KSGScriptObj *zObj, KSGSVariableDef *def )
 	{
-		return KSGSVariable::erstellVariable( zObj, def );
+		return KSGSKlasseInstanz::erstellVariable( zObj, def );
 	}
 
 	__declspec( dllexport ) void SetKSGSBildVariable( KSGSVariable *zBv, Bild *b )

ksgScript/Main/KSGScriptObj.cpp

@@ -16,378 +16,378 @@
 
 using namespace KSGScript;
 
-// Inhalt der KSGScriptObj Klasse aus KSGScriptObj.h
+// Inhalt der KSGScript Klasse aus KSGScript.h
 // Konstruktor
-KSGScriptObj::KSGScriptObj()
-{
-	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;
-	ref = 1;
-	mausP = new RCArray< KSGSVariable >();
-	tastaturP = new RCArray< KSGSVariable >();
-	tickP = new RCArray< KSGSVariable >();
-	renderP = new RCArray< KSGSVariable >();
+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;
+    ref = 1;
+    mausP = new RCArray< KSGSVariable >();
+    tastaturP = new RCArray< KSGSVariable >();
+    tickP = new RCArray< KSGSVariable >();
+    renderP = new RCArray< KSGSVariable >();
     log = 0;
 }
 
 // Destruktor
-KSGScriptObj::~KSGScriptObj()
-{
-	if( schrift )
-		schrift->release();
-	if( screen )
-		screen->release();
-	zurücksetzen();
-	mausP->release();
-	tastaturP->release();
-	tickP->release();
-	renderP->release();
-	pfad->release();
-	wd->release();
-	variablen->release();
-	funktionen->release();
-	klassen->release();
+KSGScriptO::~KSGScriptO()
+{
+    if( schrift )
+        schrift->release();
+    if( screen )
+        screen->release();
+    zurücksetzen();
+    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 KSGScriptObj::lock()
+void KSGScriptO::lock()
 {
     cs.lock();
 }
 
-void KSGScriptObj::unlock()
+void KSGScriptO::unlock()
 {
     cs.unlock();
 }
 
-void KSGScriptObj::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 KSGScriptObj::setScriptDatei( Text *pfad )
+void KSGScriptO::setScriptDatei( Text *pfad )
 {
-	setScriptDatei( pfad->getText() );
-	pfad->release();
+    setScriptDatei( pfad->getText() );
+    pfad->release();
 }
 
-bool KSGScriptObj::neuLaden()
+bool KSGScriptO::neuLaden()
 {
-	lock();
-	ZeitMesser *gzm = new ZeitMesser();
-	gzm->messungStart();
-	if( geladen )
-		zurücksetzen();
-	scrId++;
-	KSGSLeser *reader = new KSGSLeser( *pfad, this );
-	ZeitMesser *zm = new ZeitMesser();
-	zm->messungStart();
-	if( !reader->laden() )
-	{
-		reader->release();
-		zm->release();
-		gzm->release();
-		unlock();
-		return 0;
-	}
-	zm->messungEnde();
+    lock();
+    ZeitMesser *gzm = new ZeitMesser();
+    gzm->messungStart();
+    if( geladen )
+        zurücksetzen();
+    scrId++;
+    KSGSLeser *reader = new KSGSLeser( *pfad, this );
+    ZeitMesser *zm = new ZeitMesser();
+    zm->messungStart();
+    if( !reader->laden() )
+    {
+        reader->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();
-		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();
+    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();
+        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 = KSGSVariable::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();
-	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( getThis(), 0, 0 );
-			KSGSVariable *ret = inst->startFunktion();
-			if( ret )
-				ret->release();
-			if( inst->wirdFunktionAusgeführt() )
-				inst->warteAufFunktion( INFINITE );
-			inst->release();
-			break;
-		}
-	}
-	geladen = 2;
-	gzm->messungEnde();
+    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();
+    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( (KSGScriptO*)getThis(), 0, 0 );
+            KSGSVariable *ret = inst->startFunktion();
+            if( ret )
+                ret->release();
+            if( inst->wirdFunktionAusgeführt() )
+                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 KSGScriptObj::zurücksetzen()
-{
-	lock();
-	geladen = 0;
-	variablen->leeren();
-	funktionen->leeren();
-	klassen->leeren();
-	mausP->leeren();
-	tastaturP->leeren();
-	tickP->leeren();
-	renderP->leeren();
-	unlock();
-}
-
-void KSGScriptObj::setRückrufParam( void *p )
-{
-	rParam = p;
-}
-
-void KSGScriptObj::setRückrufFunktion( void( *funktion )( void *, RCArray< KSGSVariable > *, KSGSVariable ** ) )
-{
-	rFunktion = funktion;
-}
-
-void KSGScriptObj::setSchriftZ( Schrift *s )
-{
-	if( schrift )
-		schrift->release();
-	schrift = s;
-}
-
-void KSGScriptObj::setBildschirmZ( Bildschirm *s )
-{
-	if( screen )
-		screen->release();
-	screen = s;
-}
-
-void KSGScriptObj::doMausEreignis( 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( getThis(), 0, mausP->getThis() );
-			KSGSVariable *ret = inst->startFunktion();
-			if( ret )
-			{
-				me.verarbeitet |= ret->getBool();
-				ret->release();
-			}
-			if( inst->wirdFunktionAusgeführt() )
-				inst->warteAufFunktion( INFINITE );
-			inst->release();
-			break;
-		}
-	}
-	me.mx += pos.x;
-	me.my += pos.y;
-	unlock();
-}
-
-void KSGScriptObj::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( getThis(), 0, tastaturP->getThis() );
-			KSGSVariable *ret = inst->startFunktion();
-			if( ret )
-			{
-				te.verarbeitet |= ret->getBool();
-				ret->release();
-			}
-			if( inst->wirdFunktionAusgeführt() )
-				inst->warteAufFunktion( INFINITE );
-			inst->release();
-			break;
-		}
-	}
-	unlock();
-}
-
-bool KSGScriptObj::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( getThis(), 0, tickP->getThis() );
-			KSGSVariable *ret = inst->startFunktion();
-			bool r = 0;
-			if( ret )
-			{
-				r = ret->getBool();
-				ret->release();
-			}
-			if( inst->wirdFunktionAusgeführt() )
-				inst->warteAufFunktion( INFINITE );
-			inst->release();
-			unlock();
-			return r;
-		}
-	}
-	unlock();
-	return 0;
-}
-
-void KSGScriptObj::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( zRObj.getThis() );
-			KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( getThis(), 0, renderP->getThis() );
-			KSGSVariable *ret = inst->startFunktion();
-			if( ret )
-				ret->release();
-			if( inst->wirdFunktionAusgeführt() )
-				inst->warteAufFunktion( INFINITE );
-			inst->release();
-			break;
-		}
-	}
-	zRObj.releaseDrawOptions();
-	unlock();
-}
-
-KSGSVariable *KSGScriptObj::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( getThis(), 0, parameter );
-	KSGSVariable *ret = inst->startFunktion();
-	inst->release();
-	return ret;
-}
-
-KSGSVariable *KSGScriptObj::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 KSGScriptObj::setVariable( int id, KSGSVariable *var )
-{
-	variablen->set( var, id );
-}
-
-Text *KSGScriptObj::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 KSGScriptObj::setLog( TextFeld *log )
+    std::cout << "KSGS Reader: Zum laden benötigte Sekunden: " << gzm->getSekunden() << "\n";
+    gzm->release();
+    unlock();
+    return 1;
+}
+
+void KSGScriptO::zurücksetzen()
+{
+    lock();
+    geladen = 0;
+    variablen->leeren();
+    funktionen->leeren();
+    klassen->leeren();
+    mausP->leeren();
+    tastaturP->leeren();
+    tickP->leeren();
+    renderP->leeren();
+    unlock();
+}
+
+void KSGScriptO::setRückrufParam( void *p )
+{
+    rParam = p;
+}
+
+void KSGScriptO::setRückrufFunktion( 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::doMausEreignis( 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( (KSGScriptO*)getThis(), 0, mausP->getThis() );
+            KSGSVariable *ret = inst->startFunktion();
+            if( ret )
+            {
+                me.verarbeitet |= ret->getBool();
+                ret->release();
+            }
+            if( inst->wirdFunktionAusgeführt() )
+                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( (KSGScriptO*)getThis(), 0, tastaturP->getThis() );
+            KSGSVariable *ret = inst->startFunktion();
+            if( ret )
+            {
+                te.verarbeitet |= ret->getBool();
+                ret->release();
+            }
+            if( inst->wirdFunktionAusgeführt() )
+                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( (KSGScriptO*)getThis(), 0, tickP->getThis() );
+            KSGSVariable *ret = inst->startFunktion();
+            bool r = 0;
+            if( ret )
+            {
+                r = ret->getBool();
+                ret->release();
+            }
+            if( inst->wirdFunktionAusgeführt() )
+                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( zRObj.getThis() );
+            KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( (KSGScriptO*)getThis(), 0, renderP->getThis() );
+            KSGSVariable *ret = inst->startFunktion();
+            if( ret )
+                ret->release();
+            if( inst->wirdFunktionAusgeführt() )
+                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( (KSGScriptO*)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 )
@@ -396,7 +396,7 @@ void KSGScriptObj::setLog( TextFeld *log )
     unlock();
 }
 
-void KSGScriptObj::logNachricht( char *n )
+void KSGScriptO::logNachricht( char *n )
 {
     if( log )
     {
@@ -407,91 +407,91 @@ void KSGScriptObj::logNachricht( char *n )
 }
 
 // constant
-KSGSVariable *KSGScriptObj::rückruf( RCArray< KSGSVariable > *parameter ) const
+KSGSVariable *KSGScriptO::rückruf( 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 *KSGScriptObj::getScriptDateiPfad() const
+Text *KSGScriptO::getScriptDateiPfad() const
 {
-	return pfad->getThis();
+    return pfad->getThis();
 }
 
-Text *KSGScriptObj::zScriptDateiPfad() const
+Text *KSGScriptO::zScriptDateiPfad() const
 {
-	return pfad;
+    return pfad;
 }
 
-Schrift *KSGScriptObj::getSchrift() const
+Schrift *KSGScriptO::getSchrift() const
 {
-	return schrift ? schrift->getThis() : 0;
+    return schrift ? schrift->getThis() : 0;
 }
 
-Schrift *KSGScriptObj::zSchrift() const
+Schrift *KSGScriptO::zSchrift() const
 {
-	return schrift;
+    return schrift;
 }
 
-Bildschirm *KSGScriptObj::getBildschirm() const
+Bildschirm *KSGScriptO::getBildschirm() const
 {
-	return screen ? screen->getThis() : 0;
+    return screen ? screen->getThis() : 0;
 }
 
-Bildschirm *KSGScriptObj::zBildschirm() const
+Bildschirm *KSGScriptO::zBildschirm() const
 {
-	return screen;
+    return screen;
 }
 
-int KSGScriptObj::getScriptId() const
+int KSGScriptO::getScriptId() const
 {
-	return scrId;
+    return scrId;
 }
 
-bool KSGScriptObj::istBeendet( int scrId ) const
+bool KSGScriptO::istBeendet( int scrId ) const
 {
-	return !geladen || this->scrId != scrId;
+    return !geladen || this->scrId != scrId;
 }
 
-int KSGScriptObj::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 *KSGScriptObj::getVariable( int id ) const
+KSGSVariable *KSGScriptO::getVariable( int id ) const
 {
-	if( !variablen || !variablen->z( id ) )
-	{
-		error( 17, {}, (KSGScriptObj*)this );
-		return 0;
-	}
-	return variablen->get( id );
+    if( !variablen || !variablen->z( id ) )
+    {
+        error( 17, {}, ( KSGScriptO* )this );
+        return 0;
+    }
+    return variablen->get( id );
 }
 
 // Reference Counting
-KSGScriptObj *KSGScriptObj::getThis()
+KSGScriptObj *KSGScriptO::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
-KSGScriptObj *KSGScriptObj::release()
+KSGScriptObj *KSGScriptO::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

ksgScript/Main/KSGScriptObj.h

@@ -1,11 +1,11 @@
-#ifndef KSGScriptObj_H
-#define KSGScriptObj_H
+#pragma once
 
 #include <Zeichnung.h>
 #include <Text.h>
 #include <Array.h>
 #include <Schrift.h>
 #include <TextFeld.h>
+#include "../Include/KSGScript.h"
 
 using namespace Framework;
 
@@ -15,9 +15,8 @@ namespace KSGScript
 	class KSGSFunktionInstanz; // ../Befehl/KSGSFunktion.h
 	class KSGSKlasse; // ../Befehl/KSGSKlasse.h
 	class KSGSKlasseInstanz; // ../Befehl/KSGSKlasse.h
-	typedef KSGSKlasseInstanz KSGSVariable;
 
-	class KSGScriptObj : public Zeichnung
+	class KSGScriptO : public KSGScriptObj
 	{
 	private:
 		Text *pfad;
@@ -46,46 +45,44 @@ namespace KSGScript
 
 	public:
 		// Konstruktor
-		__declspec( dllexport ) KSGScriptObj();
+		__declspec( dllexport ) KSGScriptO();
 		// Destruktor
-		__declspec( dllexport ) ~KSGScriptObj();
+		__declspec( dllexport ) ~KSGScriptO();
 		// nicht constant
-		__declspec( dllexport ) virtual void lock();
-		__declspec( dllexport ) virtual void unlock();
-		__declspec( dllexport ) virtual void setScriptDatei( const char *pfad );
-		__declspec( dllexport ) virtual void setScriptDatei( Text *pfad );
-		__declspec( dllexport ) virtual bool neuLaden();
-		__declspec( dllexport ) virtual void zurücksetzen();
-		__declspec( dllexport ) virtual void setRückrufParam( void *p );
-		__declspec( dllexport ) virtual void setRückrufFunktion( void( *funktion )( void *, RCArray< KSGSVariable > *, KSGSVariable ** ) );
-		__declspec( dllexport ) virtual void setSchriftZ( Schrift *s );
-		__declspec( dllexport ) virtual void setBildschirmZ( Bildschirm *s );
-		__declspec( dllexport ) virtual void doMausEreignis( MausEreignis &me ) override;
-		__declspec( dllexport ) virtual void doTastaturEreignis( TastaturEreignis &te ) override;
-		__declspec( dllexport ) virtual bool tick( double zeit ) override;
-		__declspec( dllexport ) virtual void render( Bild &zRObj ) override;
-		__declspec( dllexport ) virtual KSGSVariable *startFunktion( int id, RCArray< KSGSVariable > *parameter );
-		__declspec( dllexport ) virtual KSGSVariable *erstellKlassenInstanz( int id );
-		__declspec( dllexport ) virtual void setVariable( int id, KSGSVariable *var );
-		__declspec( dllexport ) virtual Text *convertPfad( char *pf );
-        __declspec( dllexport ) virtual void setLog( TextFeld *log );
-        __declspec( dllexport ) virtual void logNachricht( char *n );
+		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 zurücksetzen() override;
+		virtual void setRückrufParam( void *p ) override;
+		virtual void setRückrufFunktion( void( *funktion )( void *, RCArray< KSGSVariable > *, KSGSVariable ** ) ) override;
+		virtual void setSchriftZ( Schrift *s ) override;
+		virtual void setBildschirmZ( Bildschirm *s ) override;
+		virtual void doMausEreignis( 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
-		__declspec( dllexport ) virtual KSGSVariable *rückruf( RCArray< KSGSVariable > *parameter ) const;
-		__declspec( dllexport ) virtual Text *getScriptDateiPfad() const;
-		__declspec( dllexport ) virtual Text *zScriptDateiPfad() const;
-		__declspec( dllexport ) virtual Schrift *getSchrift() const;
-		__declspec( dllexport ) virtual Schrift *zSchrift() const;
-		__declspec( dllexport ) virtual Bildschirm *getBildschirm() const;
-		__declspec( dllexport ) virtual Bildschirm *zBildschirm() const;
-		__declspec( dllexport ) virtual int getScriptId() const;
-		__declspec( dllexport ) virtual bool istBeendet( int scrId ) const;
-		__declspec( dllexport ) virtual int getFunktionId( const char *name ) const;
-		__declspec( dllexport ) virtual KSGSVariable *getVariable( int id ) const;
+		virtual KSGSVariable *rückruf( 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;
 		// Reference Counting
-		__declspec( dllexport ) virtual KSGScriptObj *getThis();
-		__declspec( dllexport ) virtual KSGScriptObj *release();
+		virtual KSGScriptObj *getThis() override;
+		virtual KSGScriptObj *release() override;
 	};
-}
-
-#endif
+}

ksgScript/ksgScript.vcxproj

@@ -176,7 +176,8 @@ copy "..\x64\Debug\ksgScript.dll" "..\..\..\Spiele Platform\Klient\Fertig\Debug\
     <ClInclude Include="Befehl\KSGSBefehl.h" />
     <ClInclude Include="Befehl\KSGSFunktion.h" />
     <ClInclude Include="Befehl\KSGSKlasse.h" />
-    <ClInclude Include="Befehl\KSGSVariable.h" />
+    <ClInclude Include="Editor\Editor.h" />
+    <ClInclude Include="Editor\Parser\ColorParser.h" />
     <ClInclude Include="Error\Error.h" />
     <ClInclude Include="Funktionen\KSGSRückruf.h" />
     <ClInclude Include="Include\KSGScript.h" />
@@ -205,6 +206,8 @@ copy "..\x64\Debug\ksgScript.dll" "..\..\..\Spiele Platform\Klient\Fertig\Debug\
     <ClCompile Include="Befehl\KSGSBefehl.cpp" />
     <ClCompile Include="Befehl\KSGSFunktion.cpp" />
     <ClCompile Include="Befehl\KSGSKlasse.cpp" />
+    <ClCompile Include="Editor\Editor.cpp" />
+    <ClCompile Include="Editor\Parser\ColorParser.cpp" />
     <ClCompile Include="Error\Error.cpp" />
     <ClCompile Include="Funktionen\KSGSRückruf.cpp" />
     <ClCompile Include="Klassen\KSGSAnimation2D.cpp" />

ksgScript/ksgScript.vcxproj.filters

@@ -78,9 +78,6 @@
     <ClInclude Include="Klassen\KSGSFenster.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Befehl\KSGSVariable.h">
-      <Filter>Headerdateien</Filter>
-    </ClInclude>
     <ClInclude Include="Funktionen\KSGSRückruf.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
@@ -96,6 +93,12 @@
     <ClInclude Include="Klassen\KSGSBildZ.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="Editor\Editor.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Parser\ColorParser.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Befehl\KSGSFunktion.cpp">
@@ -170,5 +173,11 @@
     <ClCompile Include="Klassen\KSGSBildZ.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Editor\Editor.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Parser\ColorParser.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>