|
|
@@ -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;
|
|
|
}
|
Kolja Strohm