|
@@ -13,508 +13,508 @@
|
|
|
using namespace KSGScript;
|
|
|
|
|
|
// Befehls Strukturen
|
|
|
-KSGSBefehlVariable::KSGSBefehlVariable( Text *txt, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT,
|
|
|
- const char *klassName, const char *funktionName, int *typId, bool *ok )
|
|
|
+KSGSBefehlVariable::KSGSBefehlVariable(Text* txt, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT,
|
|
|
+ const char* klassName, const char* funktionName, int* typId, bool* ok)
|
|
|
{
|
|
|
- txt->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( txt );
|
|
|
- Text name = txt->getText();
|
|
|
- txt->release();
|
|
|
- *ok = 0;
|
|
|
- if( !funktionName && !klassName )
|
|
|
- return;
|
|
|
- KSGSCompFuncTable *zLFT = zFT;
|
|
|
- KSGSCompVarTable *zLVT = zVT;
|
|
|
- if( klassName )
|
|
|
- {
|
|
|
- if( !zKT->hat( klassName ) )
|
|
|
- return;
|
|
|
- zLFT = &zKT->get( klassName )->funcs;
|
|
|
- zLVT = &zKT->get( klassName )->vars;
|
|
|
- }
|
|
|
- if( *typId >= 0 )
|
|
|
- { // Variable gehört zu einem anderen Zeichnung
|
|
|
- if( !zKT->hat( *typId ) || !zKT->get( *typId )->vars.hat( name ) )
|
|
|
- return;
|
|
|
- varId = zKT->get( *typId )->vars.get( name )->id;
|
|
|
- varSichtbar = zKT->get( *typId )->vars.get( name )->sichtbar;
|
|
|
- *typId = zKT->get( *typId )->vars.get( name )->typ;
|
|
|
- }
|
|
|
- else
|
|
|
- { // Variable gehört zu diesem Zeichnung
|
|
|
- if( !zLFT->hat( funktionName ) )
|
|
|
- return;
|
|
|
- if( zLFT->get( funktionName )->vars.hat( name ) )
|
|
|
- {
|
|
|
- varId = zLFT->get( funktionName )->vars.get( name )->id;
|
|
|
- *typId = zLFT->get( funktionName )->vars.get( name )->typ;
|
|
|
- varSichtbar = zLFT->get( funktionName )->vars.get( name )->sichtbar;
|
|
|
- }
|
|
|
- else if( zLVT->hat( name ) )
|
|
|
- {
|
|
|
- varId = zLVT->get( name )->id;
|
|
|
- *typId = zLVT->get( name )->typ;
|
|
|
- varSichtbar = zLVT->get( name )->sichtbar;
|
|
|
- }
|
|
|
- else if( zVT->hat( name ) )
|
|
|
- {
|
|
|
- varId = zVT->get( name )->id;
|
|
|
- *typId = zVT->get( name )->typ;
|
|
|
- varSichtbar = zVT->get( name )->sichtbar;
|
|
|
- }
|
|
|
- else
|
|
|
- return;
|
|
|
- }
|
|
|
- *ok = 1;
|
|
|
+ txt->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(txt);
|
|
|
+ Text name = txt->getText();
|
|
|
+ txt->release();
|
|
|
+ *ok = 0;
|
|
|
+ if (!funktionName && !klassName)
|
|
|
+ return;
|
|
|
+ KSGSCompFuncTable* zLFT = zFT;
|
|
|
+ KSGSCompVarTable* zLVT = zVT;
|
|
|
+ if (klassName)
|
|
|
+ {
|
|
|
+ if (!zKT->hat(klassName))
|
|
|
+ return;
|
|
|
+ zLFT = &zKT->get(klassName)->funcs;
|
|
|
+ zLVT = &zKT->get(klassName)->vars;
|
|
|
+ }
|
|
|
+ if (*typId >= 0)
|
|
|
+ { // Variable gehört zu einem anderen Zeichnung
|
|
|
+ if (!zKT->hat(*typId) || !zKT->get(*typId)->vars.hat(name))
|
|
|
+ return;
|
|
|
+ varId = zKT->get(*typId)->vars.get(name)->id;
|
|
|
+ varSichtbar = zKT->get(*typId)->vars.get(name)->sichtbar;
|
|
|
+ *typId = zKT->get(*typId)->vars.get(name)->typ;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ { // Variable gehört zu diesem Zeichnung
|
|
|
+ if (!zLFT->hat(funktionName))
|
|
|
+ return;
|
|
|
+ if (zLFT->get(funktionName)->vars.hat(name))
|
|
|
+ {
|
|
|
+ varId = zLFT->get(funktionName)->vars.get(name)->id;
|
|
|
+ *typId = zLFT->get(funktionName)->vars.get(name)->typ;
|
|
|
+ varSichtbar = zLFT->get(funktionName)->vars.get(name)->sichtbar;
|
|
|
+ }
|
|
|
+ else if (zLVT->hat(name))
|
|
|
+ {
|
|
|
+ varId = zLVT->get(name)->id;
|
|
|
+ *typId = zLVT->get(name)->typ;
|
|
|
+ varSichtbar = zLVT->get(name)->sichtbar;
|
|
|
+ }
|
|
|
+ else if (zVT->hat(name))
|
|
|
+ {
|
|
|
+ varId = zVT->get(name)->id;
|
|
|
+ *typId = zVT->get(name)->typ;
|
|
|
+ varSichtbar = zVT->get(name)->sichtbar;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ *ok = 1;
|
|
|
}
|
|
|
|
|
|
-KSGSBefehlFunktion::KSGSBefehlFunktion( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT, KSGSCompVarTable *zVT,
|
|
|
- const char *klassName, const char *funktionName, int *typId, bool *ok )
|
|
|
+KSGSBefehlFunktion::KSGSBefehlFunktion(KSGScriptProcessor* zObj, Text* txt, KSGSLeseDebug* dbg, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT, KSGSCompVarTable* zVT,
|
|
|
+ const char* klassName, const char* funktionName, int* typId, bool* ok)
|
|
|
{
|
|
|
- *ok = 0;
|
|
|
- int retTyp = -1;
|
|
|
- txt->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( txt );
|
|
|
- if( !txt->hat( '(' ) || ( !klassName && !funktionName ) )
|
|
|
- {
|
|
|
- txt->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- Text *name = txt->getTeilText( 0, txt->positionVon( '(' ) );
|
|
|
- Text *parameter = txt->getTeilText( txt->positionVon( '(' ) );
|
|
|
- txt->release();
|
|
|
- name->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( name );
|
|
|
- parameter->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( parameter );
|
|
|
- KSGSCompFuncTable *zLFT = zFT;
|
|
|
- if( klassName )
|
|
|
- {
|
|
|
- if( !zKT->hat( klassName ) )
|
|
|
- {
|
|
|
- name->release();
|
|
|
- parameter->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- zLFT = &zKT->get( klassName )->funcs;
|
|
|
- }
|
|
|
- if( *typId >= 0 )
|
|
|
- { // Funktion gehört zu anderem Zeichnung
|
|
|
- if( !zKT->hat( *typId ) )
|
|
|
- {
|
|
|
- name->release();
|
|
|
- parameter->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- zLFT = &zKT->get( *typId )->funcs;
|
|
|
- }
|
|
|
- Array< int > *paramTyps = 0;
|
|
|
- bool noWarn = 0;
|
|
|
- if( zLFT->hat( *name ) )
|
|
|
- {
|
|
|
- funcId = zLFT->get( *name )->id;
|
|
|
- if( funcId == 0 && name->istGleich( "Rückruf" ) )
|
|
|
- noWarn = 1;
|
|
|
- funkSichtbar = zLFT->get( *name )->sichtbar;
|
|
|
- paramTyps = &zLFT->get( *name )->parameterTyp;
|
|
|
- retTyp = zLFT->get( *name )->typ;
|
|
|
- }
|
|
|
- else if( *typId < 0 && zFT->hat( *name ) )
|
|
|
- {
|
|
|
- funcId = zFT->get( *name )->id;
|
|
|
- if( funcId == 0 && name->istGleich( "Rückruf" ) )
|
|
|
- noWarn = 1;
|
|
|
- funkSichtbar = zFT->get( *name )->sichtbar;
|
|
|
- paramTyps = &zFT->get( *name )->parameterTyp;
|
|
|
- retTyp = zFT->get( *name )->typ;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- name->release();
|
|
|
- parameter->release();
|
|
|
- return;
|
|
|
- } // Parameter
|
|
|
- int ptAnz = paramTyps->getEintragAnzahl();
|
|
|
- int pAnz = parameter->anzahlVon( ',' ) + 1;
|
|
|
- if( !parameter->getLength() )
|
|
|
- pAnz = 0;
|
|
|
- if( ptAnz != pAnz )
|
|
|
- {
|
|
|
- if( !noWarn )
|
|
|
- error( 14, { dbg->datei, Text() += dbg->zeile }, zObj );
|
|
|
- ptAnz = ptAnz < pAnz ? pAnz : ptAnz;
|
|
|
- }
|
|
|
- for( int i = 0; i < ptAnz; i++ )
|
|
|
- { // für jeden Parameter
|
|
|
- int beg = 0;
|
|
|
- int end = parameter->getLength();
|
|
|
- if( i > 0 )
|
|
|
- beg = parameter->positionVon( ',', i - 1 ) + 1;
|
|
|
- if( i < ptAnz - 1 )
|
|
|
- end = parameter->positionVon( ',', i );
|
|
|
- Text *p = parameter->getTeilText( beg, end );
|
|
|
- bool b = 0;
|
|
|
- int pTyp = -1;
|
|
|
- KSGSBefehlParameter *param = new KSGSBefehlParameter( zObj, p, dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- name->release();
|
|
|
- parameter->release();
|
|
|
- delete param;
|
|
|
- return;
|
|
|
- }
|
|
|
- this->parameter.add( param );
|
|
|
- }
|
|
|
- name->release();
|
|
|
- parameter->release();
|
|
|
- *typId = retTyp;
|
|
|
- *ok = 1;
|
|
|
+ *ok = 0;
|
|
|
+ int retTyp = -1;
|
|
|
+ txt->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(txt);
|
|
|
+ if (!txt->hat('(') || (!klassName && !funktionName))
|
|
|
+ {
|
|
|
+ txt->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ Text* name = txt->getTeilText(0, txt->positionVon('('));
|
|
|
+ Text* parameter = txt->getTeilText(txt->positionVon('('));
|
|
|
+ txt->release();
|
|
|
+ name->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(name);
|
|
|
+ parameter->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(parameter);
|
|
|
+ KSGSCompFuncTable* zLFT = zFT;
|
|
|
+ if (klassName)
|
|
|
+ {
|
|
|
+ if (!zKT->hat(klassName))
|
|
|
+ {
|
|
|
+ name->release();
|
|
|
+ parameter->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ zLFT = &zKT->get(klassName)->funcs;
|
|
|
+ }
|
|
|
+ if (*typId >= 0)
|
|
|
+ { // Funktion gehört zu anderem Zeichnung
|
|
|
+ if (!zKT->hat(*typId))
|
|
|
+ {
|
|
|
+ name->release();
|
|
|
+ parameter->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ zLFT = &zKT->get(*typId)->funcs;
|
|
|
+ }
|
|
|
+ Array< int >* paramTyps = 0;
|
|
|
+ bool noWarn = 0;
|
|
|
+ if (zLFT->hat(*name))
|
|
|
+ {
|
|
|
+ funcId = zLFT->get(*name)->id;
|
|
|
+ if (funcId == 0 && name->istGleich("Rückruf"))
|
|
|
+ noWarn = 1;
|
|
|
+ funkSichtbar = zLFT->get(*name)->sichtbar;
|
|
|
+ paramTyps = &zLFT->get(*name)->parameterTyp;
|
|
|
+ retTyp = zLFT->get(*name)->typ;
|
|
|
+ }
|
|
|
+ else if (*typId < 0 && zFT->hat(*name))
|
|
|
+ {
|
|
|
+ funcId = zFT->get(*name)->id;
|
|
|
+ if (funcId == 0 && name->istGleich("Rückruf"))
|
|
|
+ noWarn = 1;
|
|
|
+ funkSichtbar = zFT->get(*name)->sichtbar;
|
|
|
+ paramTyps = &zFT->get(*name)->parameterTyp;
|
|
|
+ retTyp = zFT->get(*name)->typ;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ name->release();
|
|
|
+ parameter->release();
|
|
|
+ return;
|
|
|
+ } // Parameter
|
|
|
+ int ptAnz = paramTyps->getEintragAnzahl();
|
|
|
+ int pAnz = parameter->anzahlVon(',') + 1;
|
|
|
+ if (!parameter->getLength())
|
|
|
+ pAnz = 0;
|
|
|
+ if (ptAnz != pAnz)
|
|
|
+ {
|
|
|
+ if (!noWarn)
|
|
|
+ error(14, { dbg->datei, Text() += dbg->zeile }, zObj);
|
|
|
+ ptAnz = ptAnz < pAnz ? pAnz : ptAnz;
|
|
|
+ }
|
|
|
+ for (int i = 0; i < ptAnz; i++)
|
|
|
+ { // für jeden Parameter
|
|
|
+ int beg = 0;
|
|
|
+ int end = parameter->getLength();
|
|
|
+ if (i > 0)
|
|
|
+ beg = parameter->positionVon(',', i - 1) + 1;
|
|
|
+ if (i < ptAnz - 1)
|
|
|
+ end = parameter->positionVon(',', i);
|
|
|
+ Text* p = parameter->getTeilText(beg, end);
|
|
|
+ bool b = 0;
|
|
|
+ int pTyp = -1;
|
|
|
+ KSGSBefehlParameter* param = new KSGSBefehlParameter(zObj, p, dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ name->release();
|
|
|
+ parameter->release();
|
|
|
+ delete param;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ this->parameter.add(param);
|
|
|
+ }
|
|
|
+ name->release();
|
|
|
+ parameter->release();
|
|
|
+ *typId = retTyp;
|
|
|
+ *ok = 1;
|
|
|
}
|
|
|
|
|
|
KSGSBefehlFunktion::~KSGSBefehlFunktion()
|
|
|
{
|
|
|
- int anz = parameter.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- delete parameter.get( i );
|
|
|
+ int anz = parameter.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ delete parameter.get(i);
|
|
|
}
|
|
|
|
|
|
-KSGSBefehlMember::KSGSBefehlMember( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName, int *typId, bool *ok )
|
|
|
+KSGSBefehlMember::KSGSBefehlMember(KSGScriptProcessor* zObj, Text* txt, KSGSLeseDebug* dbg, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName, int* typId, bool* ok)
|
|
|
{
|
|
|
- *ok = 0;
|
|
|
- bef = 0;
|
|
|
- funk = 0;
|
|
|
- var = 0;
|
|
|
- txt->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( txt );
|
|
|
- Text abschnitt = txt->getText();
|
|
|
- abschnitt.setSuchGrenzen( '(', ')' );
|
|
|
- txt->release();
|
|
|
- if( hatOperator( &abschnitt ) >= 0 )
|
|
|
- { // Befehl
|
|
|
- typ = BEFEHL;
|
|
|
- KSGSLeseBefehl *tmp = new KSGSLeseBefehl();
|
|
|
- tmp->befehl = abschnitt.getText();
|
|
|
- tmp->befehl.setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( &tmp->befehl );
|
|
|
- tmp->debug.datei = dbg->datei.getText();
|
|
|
- tmp->debug.zeile = dbg->zeile;
|
|
|
- tmp->typ = 0;
|
|
|
- bef = new KSGSOperatorBefehl( zObj, tmp, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- delete tmp;
|
|
|
- if( bef->hatFehler() )
|
|
|
- return;
|
|
|
- *typId = bef->getReturnTyp();
|
|
|
- }
|
|
|
- else if( abschnitt.hat( '(' ) )
|
|
|
- { // Funktionsaufruf
|
|
|
- typ = FUNKTION;
|
|
|
- bool b = 0;
|
|
|
- funk = new KSGSBefehlFunktion( zObj, dynamic_cast<Text *>( abschnitt.getThis() ), dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b );
|
|
|
- if( !b )
|
|
|
- return;
|
|
|
- }
|
|
|
- else
|
|
|
- { // Variable
|
|
|
- typ = VARIABLE;
|
|
|
- bool b = 0;
|
|
|
- var = new KSGSBefehlVariable( dynamic_cast<Text *>( abschnitt.getThis() ), zKT, zFT, zVT, klassName, funktionName, typId, &b );
|
|
|
- if( !b )
|
|
|
- return;
|
|
|
- }
|
|
|
- *ok = 1;
|
|
|
+ *ok = 0;
|
|
|
+ bef = 0;
|
|
|
+ funk = 0;
|
|
|
+ var = 0;
|
|
|
+ txt->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(txt);
|
|
|
+ Text abschnitt = txt->getText();
|
|
|
+ abschnitt.setSuchGrenzen('(', ')');
|
|
|
+ txt->release();
|
|
|
+ if (hatOperator(&abschnitt) >= 0)
|
|
|
+ { // Befehl
|
|
|
+ typ = BEFEHL;
|
|
|
+ KSGSLeseBefehl* tmp = new KSGSLeseBefehl();
|
|
|
+ tmp->befehl = abschnitt.getText();
|
|
|
+ tmp->befehl.setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(&tmp->befehl);
|
|
|
+ tmp->debug.datei = dbg->datei.getText();
|
|
|
+ tmp->debug.zeile = dbg->zeile;
|
|
|
+ tmp->typ = 0;
|
|
|
+ bef = new KSGSOperatorBefehl(zObj, tmp, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ delete tmp;
|
|
|
+ if (bef->hatFehler())
|
|
|
+ return;
|
|
|
+ *typId = bef->getReturnTyp();
|
|
|
+ }
|
|
|
+ else if (abschnitt.hat('('))
|
|
|
+ { // Funktionsaufruf
|
|
|
+ typ = FUNKTION;
|
|
|
+ bool b = 0;
|
|
|
+ funk = new KSGSBefehlFunktion(zObj, dynamic_cast<Text*>(abschnitt.getThis()), dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b);
|
|
|
+ if (!b)
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ { // Variable
|
|
|
+ typ = VARIABLE;
|
|
|
+ bool b = 0;
|
|
|
+ var = new KSGSBefehlVariable(dynamic_cast<Text*>(abschnitt.getThis()), zKT, zFT, zVT, klassName, funktionName, typId, &b);
|
|
|
+ if (!b)
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ *ok = 1;
|
|
|
}
|
|
|
|
|
|
KSGSBefehlMember::~KSGSBefehlMember()
|
|
|
{
|
|
|
- if( bef )
|
|
|
- bef->release();
|
|
|
- delete funk;
|
|
|
- delete var;
|
|
|
+ if (bef)
|
|
|
+ bef->release();
|
|
|
+ delete funk;
|
|
|
+ delete var;
|
|
|
}
|
|
|
|
|
|
-KSGSBefehlParameter::KSGSBefehlParameter( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName, int *typId, bool *ok )
|
|
|
+KSGSBefehlParameter::KSGSBefehlParameter(KSGScriptProcessor* zObj, Text* txt, KSGSLeseDebug* dbg, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName, int* typId, bool* ok)
|
|
|
{
|
|
|
- *typId = -1;
|
|
|
- *ok = 0;
|
|
|
- Text param = txt->getText();
|
|
|
- param.setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( ¶m );
|
|
|
- txt->release();
|
|
|
- if( !param.getLength() || ( !klassName && !funktionName ) )
|
|
|
- return;
|
|
|
- if( param.getLength() > 2 && param[ 0 ] == '0' && param[ 1 ] == 'x' )
|
|
|
- { // Hex Zahl
|
|
|
- typ = WERT;
|
|
|
- wert = (int)param;
|
|
|
- *typId = zKT->get( "int" )->id;
|
|
|
- }
|
|
|
- else if( param.getLength() == 3 && param[ 0 ] == '\'' && param[ 2 ] == '\'' )
|
|
|
- { // Char
|
|
|
- typ = WERT;
|
|
|
- wert = (int)param[ 1 ];
|
|
|
- *typId = zKT->get( "int" )->id;
|
|
|
- }
|
|
|
- else if( param.getLength() > 1 && param[ 0 ] == '"' && param[ param.getLength() - 1 ] == '"' )
|
|
|
- { // Text
|
|
|
- typ = WERT;
|
|
|
- int anz = param.getLength();
|
|
|
- bool backSlash = 0;
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- if( param[ i ] == '\\' )
|
|
|
- {
|
|
|
- if( backSlash )
|
|
|
- {
|
|
|
- wert.append( '\\' );
|
|
|
- backSlash = 0;
|
|
|
- }
|
|
|
- else
|
|
|
- backSlash = 1;
|
|
|
- }
|
|
|
- else if( backSlash )
|
|
|
- {
|
|
|
- switch( param[ i ] )
|
|
|
- {
|
|
|
- case 'n':
|
|
|
- wert.append( '\n' );
|
|
|
- break;
|
|
|
- case 'r':
|
|
|
- wert.append( '\r' );
|
|
|
- break;
|
|
|
- case 't':
|
|
|
- wert.append( '\t' );
|
|
|
- break;
|
|
|
- case '"':
|
|
|
- wert.append( '"' );
|
|
|
- break;
|
|
|
- case '0':
|
|
|
- wert.append( '\0' );
|
|
|
- break;
|
|
|
- case '1':
|
|
|
- wert.append( '\1' );
|
|
|
- break;
|
|
|
- case '2':
|
|
|
- wert.append( '\2' );
|
|
|
- break;
|
|
|
- case '3':
|
|
|
- wert.append( '\3' );
|
|
|
- break;
|
|
|
- case '4':
|
|
|
- wert.append( '\4' );
|
|
|
- break;
|
|
|
- case '5':
|
|
|
- wert.append( '\5' );
|
|
|
- break;
|
|
|
- case '6':
|
|
|
- wert.append( '\6' );
|
|
|
- break;
|
|
|
- case '7':
|
|
|
- wert.append( '\7' );
|
|
|
- break;
|
|
|
- case '8':
|
|
|
- wert.append( '\x8' );
|
|
|
- break;
|
|
|
- case '9':
|
|
|
- wert.append( '\x9' );
|
|
|
- break;
|
|
|
- }
|
|
|
- backSlash = 0;
|
|
|
- }
|
|
|
- else
|
|
|
- wert.append( param[ i ] );
|
|
|
- }
|
|
|
- *typId = zKT->get( "Text" )->id;
|
|
|
- }
|
|
|
- else if( param.istGleich( "true" ) )
|
|
|
- { // True
|
|
|
- typ = WERT;
|
|
|
- wert = "true";
|
|
|
- *typId = zKT->get( "Text" )->id;
|
|
|
- }
|
|
|
- else if( param.istGleich( "false" ) )
|
|
|
- { // False
|
|
|
- typ = WERT;
|
|
|
- wert = "false";
|
|
|
- *typId = zKT->get( "Text" )->id;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- bool num = 1;
|
|
|
- bool p = 0;
|
|
|
- bool m = 0;
|
|
|
- for( int i = 0; i < param.getLength(); i++ )
|
|
|
- {
|
|
|
- num &= ( param[ i ] >= '0' && param[ i ] <= '9' ) || param[ i ] == '.' || param[ i ] == '-';
|
|
|
- if( param[ i ] == '.' )
|
|
|
- {
|
|
|
- if( p )
|
|
|
- num = 0;
|
|
|
- p = 1;
|
|
|
- }
|
|
|
- if( param[ i ] == '-' )
|
|
|
- {
|
|
|
- if( m )
|
|
|
- num = 0;
|
|
|
- m = 1;
|
|
|
- }
|
|
|
- }
|
|
|
- if( num )
|
|
|
- { // Zahl
|
|
|
- typ = WERT;
|
|
|
- if( !p )
|
|
|
- {
|
|
|
- wert = (int)param;
|
|
|
- *typId = KSGS_INT;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- wert = (double)param;
|
|
|
- *typId = KSGS_DOUBLE;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- { // Objekt
|
|
|
- typ = OBJEKT;
|
|
|
- if( hatOperator( ¶m ) >= 0 )
|
|
|
- { // Befehl
|
|
|
- bool b = 0;
|
|
|
- KSGSBefehlMember *obj = new KSGSBefehlMember( zObj, dynamic_cast<Text *>( param.getThis() ), dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- delete obj;
|
|
|
- return;
|
|
|
- }
|
|
|
- objekt.add( obj );
|
|
|
- }
|
|
|
- else
|
|
|
- { // Zeichnung Kette
|
|
|
- int abschnittAnz = param.anzahlVon( '.' ) + 1;
|
|
|
- int *abschnittEnde = new int[ abschnittAnz ];
|
|
|
- for( int i = 0; i < abschnittAnz - 1; i++ )
|
|
|
- abschnittEnde[ i ] = param.positionVon( '.', i );
|
|
|
- abschnittEnde[ abschnittAnz - 1 ] = param.getLength();
|
|
|
- for( int i = 0; i < abschnittAnz; i++ )
|
|
|
- {
|
|
|
- int beg = 0;
|
|
|
- if( i > 0 )
|
|
|
- beg = abschnittEnde[ i - 1 ] + 1;
|
|
|
- int end = abschnittEnde[ i ];
|
|
|
- Text *abschnitt = param.getTeilText( beg, end );
|
|
|
- bool b = 0;
|
|
|
- KSGSBefehlMember *mem = new KSGSBefehlMember( zObj, abschnitt, dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- delete mem;
|
|
|
- delete[] abschnittEnde;
|
|
|
- return;
|
|
|
- }
|
|
|
- objekt.add( mem );
|
|
|
- }
|
|
|
- delete[] abschnittEnde;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- *ok = 1;
|
|
|
+ *typId = -1;
|
|
|
+ *ok = 0;
|
|
|
+ Text param = txt->getText();
|
|
|
+ param.setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(¶m);
|
|
|
+ txt->release();
|
|
|
+ if (!param.getLength() || (!klassName && !funktionName))
|
|
|
+ return;
|
|
|
+ if (param.getLength() > 2 && param[0] == '0' && param[1] == 'x')
|
|
|
+ { // Hex Zahl
|
|
|
+ typ = WERT;
|
|
|
+ wert = (int)param;
|
|
|
+ *typId = zKT->get("int")->id;
|
|
|
+ }
|
|
|
+ else if (param.getLength() == 3 && param[0] == '\'' && param[2] == '\'')
|
|
|
+ { // Char
|
|
|
+ typ = WERT;
|
|
|
+ wert = (int)param[1];
|
|
|
+ *typId = zKT->get("int")->id;
|
|
|
+ }
|
|
|
+ else if (param.getLength() > 1 && param[0] == '"' && param[param.getLength() - 1] == '"')
|
|
|
+ { // Text
|
|
|
+ typ = WERT;
|
|
|
+ int anz = param.getLength();
|
|
|
+ bool backSlash = 0;
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ if (param[i] == '\\')
|
|
|
+ {
|
|
|
+ if (backSlash)
|
|
|
+ {
|
|
|
+ wert.append('\\');
|
|
|
+ backSlash = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ backSlash = 1;
|
|
|
+ }
|
|
|
+ else if (backSlash)
|
|
|
+ {
|
|
|
+ switch (param[i])
|
|
|
+ {
|
|
|
+ case 'n':
|
|
|
+ wert.append('\n');
|
|
|
+ break;
|
|
|
+ case 'r':
|
|
|
+ wert.append('\r');
|
|
|
+ break;
|
|
|
+ case 't':
|
|
|
+ wert.append('\t');
|
|
|
+ break;
|
|
|
+ case '"':
|
|
|
+ wert.append('"');
|
|
|
+ break;
|
|
|
+ case '0':
|
|
|
+ wert.append('\0');
|
|
|
+ break;
|
|
|
+ case '1':
|
|
|
+ wert.append('\1');
|
|
|
+ break;
|
|
|
+ case '2':
|
|
|
+ wert.append('\2');
|
|
|
+ break;
|
|
|
+ case '3':
|
|
|
+ wert.append('\3');
|
|
|
+ break;
|
|
|
+ case '4':
|
|
|
+ wert.append('\4');
|
|
|
+ break;
|
|
|
+ case '5':
|
|
|
+ wert.append('\5');
|
|
|
+ break;
|
|
|
+ case '6':
|
|
|
+ wert.append('\6');
|
|
|
+ break;
|
|
|
+ case '7':
|
|
|
+ wert.append('\7');
|
|
|
+ break;
|
|
|
+ case '8':
|
|
|
+ wert.append('\x8');
|
|
|
+ break;
|
|
|
+ case '9':
|
|
|
+ wert.append('\x9');
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ backSlash = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ wert.append(param[i]);
|
|
|
+ }
|
|
|
+ *typId = zKT->get("Text")->id;
|
|
|
+ }
|
|
|
+ else if (param.istGleich("true"))
|
|
|
+ { // True
|
|
|
+ typ = WERT;
|
|
|
+ wert = "true";
|
|
|
+ *typId = zKT->get("Text")->id;
|
|
|
+ }
|
|
|
+ else if (param.istGleich("false"))
|
|
|
+ { // False
|
|
|
+ typ = WERT;
|
|
|
+ wert = "false";
|
|
|
+ *typId = zKT->get("Text")->id;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ bool num = 1;
|
|
|
+ bool p = 0;
|
|
|
+ bool m = 0;
|
|
|
+ for (int i = 0; i < param.getLength(); i++)
|
|
|
+ {
|
|
|
+ num &= (param[i] >= '0' && param[i] <= '9') || param[i] == '.' || param[i] == '-';
|
|
|
+ if (param[i] == '.')
|
|
|
+ {
|
|
|
+ if (p)
|
|
|
+ num = 0;
|
|
|
+ p = 1;
|
|
|
+ }
|
|
|
+ if (param[i] == '-')
|
|
|
+ {
|
|
|
+ if (m)
|
|
|
+ num = 0;
|
|
|
+ m = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (num)
|
|
|
+ { // Zahl
|
|
|
+ typ = WERT;
|
|
|
+ if (!p)
|
|
|
+ {
|
|
|
+ wert = (int)param;
|
|
|
+ *typId = KSGS_INT;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ wert = (double)param;
|
|
|
+ *typId = KSGS_DOUBLE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ { // Objekt
|
|
|
+ typ = OBJEKT;
|
|
|
+ if (hatOperator(¶m) >= 0)
|
|
|
+ { // Befehl
|
|
|
+ bool b = 0;
|
|
|
+ KSGSBefehlMember* obj = new KSGSBefehlMember(zObj, dynamic_cast<Text*>(param.getThis()), dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ delete obj;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ objekt.add(obj);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ { // Zeichnung Kette
|
|
|
+ int abschnittAnz = param.anzahlVon('.') + 1;
|
|
|
+ int* abschnittEnde = new int[abschnittAnz];
|
|
|
+ for (int i = 0; i < abschnittAnz - 1; i++)
|
|
|
+ abschnittEnde[i] = param.positionVon('.', i);
|
|
|
+ abschnittEnde[abschnittAnz - 1] = param.getLength();
|
|
|
+ for (int i = 0; i < abschnittAnz; i++)
|
|
|
+ {
|
|
|
+ int beg = 0;
|
|
|
+ if (i > 0)
|
|
|
+ beg = abschnittEnde[i - 1] + 1;
|
|
|
+ int end = abschnittEnde[i];
|
|
|
+ Text* abschnitt = param.getTeilText(beg, end);
|
|
|
+ bool b = 0;
|
|
|
+ KSGSBefehlMember* mem = new KSGSBefehlMember(zObj, abschnitt, dbg, zKT, zFT, zVT, klassName, funktionName, typId, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ delete mem;
|
|
|
+ delete[] abschnittEnde;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ objekt.add(mem);
|
|
|
+ }
|
|
|
+ delete[] abschnittEnde;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ *ok = 1;
|
|
|
}
|
|
|
|
|
|
KSGSBefehlParameter::~KSGSBefehlParameter()
|
|
|
{
|
|
|
- int anz = objekt.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- delete objekt.get( i );
|
|
|
+ int anz = objekt.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ delete objekt.get(i);
|
|
|
}
|
|
|
|
|
|
-KSGSBefehlErstell::KSGSBefehlErstell( KSGScriptProcessor *zObj, Text *txt, KSGSLeseDebug *dbg, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName, bool *ok )
|
|
|
+KSGSBefehlErstell::KSGSBefehlErstell(KSGScriptProcessor* zObj, Text* txt, KSGSLeseDebug* dbg, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName, bool* ok)
|
|
|
{
|
|
|
- param = 0;
|
|
|
- konstruktor = 0;
|
|
|
- *ok = 0;
|
|
|
- Text text = txt->getText();
|
|
|
- text.setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( &text );
|
|
|
- txt->release();
|
|
|
- if( !text.getLength() || ( !klassName && !funktionName ) )
|
|
|
- return;
|
|
|
- KSGSCompFuncTable *zLFT = zFT;
|
|
|
- if( klassName )
|
|
|
- zLFT = &zKT->get( klassName )->funcs;
|
|
|
- Text *typ = text.getTeilText( 0, text.positionVon( ' ' ) );
|
|
|
- typ->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( typ );
|
|
|
- if( !zKT->hat( (char *)*typ ) )
|
|
|
- {
|
|
|
- typ->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- typId = zKT->get( (char *)*typ )->id;
|
|
|
- char endC = 0;
|
|
|
- if( text.hat( '(' ) )
|
|
|
- {
|
|
|
- endC = '(';
|
|
|
- Text *name = text.getTeilText( text.positionVon( ' ' ) + 1, text.positionVon( '(' ) );
|
|
|
- konstruktor = 1;
|
|
|
- Text befehl = name->getText();
|
|
|
- name->release();
|
|
|
- befehl += ".";
|
|
|
- befehl += typ->getText();
|
|
|
- befehl += &text[ text.positionVon( '(' ) ];
|
|
|
- bool b = 0;
|
|
|
- int pTyp = -1;
|
|
|
- param = new KSGSBefehlParameter( zObj, dynamic_cast<Text *>( befehl.getThis() ), dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- typ->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- else if( text.hat( '=' ) )
|
|
|
- {
|
|
|
- endC = '=';
|
|
|
- konstruktor = 0;
|
|
|
- Text *p = text.getTeilText( text.positionVon( '=' ) + 1 );
|
|
|
- p->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( p );
|
|
|
- bool b = 0;
|
|
|
- int pTyp = -1;
|
|
|
- param = new KSGSBefehlParameter( zObj, p, dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- typ->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- typ->release();
|
|
|
- Text *name = text.getTeilText( text.positionVon( ' ' ) + 1, endC ? text.positionVon( endC ) : text.getLength() );
|
|
|
- name->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( name );
|
|
|
- if( zLFT->get( funktionName )->vars.hat( *name ) )
|
|
|
- {
|
|
|
- name->release();
|
|
|
- return;
|
|
|
- }
|
|
|
- zLFT->get( funktionName )->vars.addVariable( *name, new KSGSCompileVariable( typId, 3 ) );
|
|
|
- id = zLFT->get( funktionName )->vars.get( *name )->id;
|
|
|
- name->release();
|
|
|
- *ok = 1;
|
|
|
+ param = 0;
|
|
|
+ konstruktor = 0;
|
|
|
+ *ok = 0;
|
|
|
+ Text text = txt->getText();
|
|
|
+ text.setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(&text);
|
|
|
+ txt->release();
|
|
|
+ if (!text.getLength() || (!klassName && !funktionName))
|
|
|
+ return;
|
|
|
+ KSGSCompFuncTable* zLFT = zFT;
|
|
|
+ if (klassName)
|
|
|
+ zLFT = &zKT->get(klassName)->funcs;
|
|
|
+ Text* typ = text.getTeilText(0, text.positionVon(' '));
|
|
|
+ typ->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(typ);
|
|
|
+ if (!zKT->hat((const char*)*typ))
|
|
|
+ {
|
|
|
+ typ->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ typId = zKT->get((const char*)*typ)->id;
|
|
|
+ char endC = 0;
|
|
|
+ if (text.hat('('))
|
|
|
+ {
|
|
|
+ endC = '(';
|
|
|
+ Text* name = text.getTeilText(text.positionVon(' ') + 1, text.positionVon('('));
|
|
|
+ konstruktor = 1;
|
|
|
+ Text befehl = name->getText();
|
|
|
+ name->release();
|
|
|
+ befehl += ".";
|
|
|
+ befehl += typ->getText();
|
|
|
+ befehl += &text[text.positionVon('(')];
|
|
|
+ bool b = 0;
|
|
|
+ int pTyp = -1;
|
|
|
+ param = new KSGSBefehlParameter(zObj, dynamic_cast<Text*>(befehl.getThis()), dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ typ->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (text.hat('='))
|
|
|
+ {
|
|
|
+ endC = '=';
|
|
|
+ konstruktor = 0;
|
|
|
+ Text* p = text.getTeilText(text.positionVon('=') + 1);
|
|
|
+ p->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(p);
|
|
|
+ bool b = 0;
|
|
|
+ int pTyp = -1;
|
|
|
+ param = new KSGSBefehlParameter(zObj, p, dbg, zKT, zFT, zVT, klassName, funktionName, &pTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ typ->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ typ->release();
|
|
|
+ Text* name = text.getTeilText(text.positionVon(' ') + 1, endC ? text.positionVon(endC) : text.getLength());
|
|
|
+ name->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(name);
|
|
|
+ if (zLFT->get(funktionName)->vars.hat(*name))
|
|
|
+ {
|
|
|
+ name->release();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ zLFT->get(funktionName)->vars.addVariable(*name, new KSGSCompileVariable(typId, 3));
|
|
|
+ id = zLFT->get(funktionName)->vars.get(*name)->id;
|
|
|
+ name->release();
|
|
|
+ *ok = 1;
|
|
|
}
|
|
|
|
|
|
KSGSBefehlErstell::~KSGSBefehlErstell()
|
|
|
{
|
|
|
- delete param;
|
|
|
+ delete param;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSBefehl::KSGSBefehl( Typ typ )
|
|
|
- : ReferenceCounter()
|
|
|
+KSGSBefehl::KSGSBefehl(Typ typ)
|
|
|
+ : ReferenceCounter()
|
|
|
{
|
|
|
- this->typ = typ;
|
|
|
- fehler = 0;
|
|
|
- returnTyp = -1;
|
|
|
+ this->typ = typ;
|
|
|
+ fehler = 0;
|
|
|
+ returnTyp = -1;
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
@@ -524,953 +524,953 @@ KSGSBefehl::~KSGSBefehl()
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- return 0;
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
bool KSGSBefehl::hatFehler() const
|
|
|
{
|
|
|
- return fehler;
|
|
|
+ return fehler;
|
|
|
}
|
|
|
|
|
|
int KSGSBefehl::getReturnTyp() const
|
|
|
{
|
|
|
- return returnTyp;
|
|
|
+ return returnTyp;
|
|
|
}
|
|
|
|
|
|
-bool KSGSBefehl::istTyp( Typ t ) const
|
|
|
+bool KSGSBefehl::istTyp(Typ t) const
|
|
|
{
|
|
|
- return typ == t;
|
|
|
+ return typ == t;
|
|
|
}
|
|
|
|
|
|
// static
|
|
|
-KSGSVariable *KSGSBefehl::prozessVariable( KSGSVariable *zVorObj, KSGSBefehlVariable *zVar, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
|
|
|
+KSGSVariable* KSGSBefehl::prozessVariable(KSGSVariable* zVorObj, KSGSBefehlVariable* zVar, KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI)
|
|
|
{
|
|
|
- if( !zVar )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- switch( zVar->varSichtbar )
|
|
|
- {
|
|
|
- case 0: // public
|
|
|
- if( !zVorObj )
|
|
|
- return zObj->getVariable( zVar->varId );
|
|
|
- break;
|
|
|
- case 1: // public in Klasse
|
|
|
- if( zVorObj )
|
|
|
- return zVorObj->getVariable( zVar->varId, 0 );
|
|
|
- else if( zKI )
|
|
|
- return zKI->getVariable( zVar->varId, 1 );
|
|
|
- break;
|
|
|
- case 2: // privat in Klasse
|
|
|
- if( zKI && !zVorObj )
|
|
|
- return zKI->getVariable( zVar->varId, 1 );
|
|
|
- break;
|
|
|
- case 3: // lokal in Funktion
|
|
|
- if( !zVorObj && zFI )
|
|
|
- return zFI->getVariable( zVar->varId );
|
|
|
- break;
|
|
|
- }
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
+ if (!zVar)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ switch (zVar->varSichtbar)
|
|
|
+ {
|
|
|
+ case 0: // public
|
|
|
+ if (!zVorObj)
|
|
|
+ return zObj->getVariable(zVar->varId);
|
|
|
+ break;
|
|
|
+ case 1: // public in Klasse
|
|
|
+ if (zVorObj)
|
|
|
+ return zVorObj->getVariable(zVar->varId, 0);
|
|
|
+ else if (zKI)
|
|
|
+ return zKI->getVariable(zVar->varId, 1);
|
|
|
+ break;
|
|
|
+ case 2: // privat in Klasse
|
|
|
+ if (zKI && !zVorObj)
|
|
|
+ return zKI->getVariable(zVar->varId, 1);
|
|
|
+ break;
|
|
|
+ case 3: // lokal in Funktion
|
|
|
+ if (!zVorObj && zFI)
|
|
|
+ return zFI->getVariable(zVar->varId);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-KSGSVariable *KSGSBefehl::prozessFunktion( KSGSVariable *zVorObj, KSGSBefehlFunktion *zFunk, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
|
|
|
+KSGSVariable* KSGSBefehl::prozessFunktion(KSGSVariable* zVorObj, KSGSBefehlFunktion* zFunk, KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI)
|
|
|
{
|
|
|
- if( !zFunk )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- RCArray< KSGSVariable > *parameter = new RCArray< KSGSVariable >();
|
|
|
- int pAnz = zFunk->parameter.getEintragAnzahl();
|
|
|
- for( int i = 0; i < pAnz; i++ )
|
|
|
- parameter->set( prozessParameter( zFunk->parameter.get( i ), zObj, zFI, zKI ), i );
|
|
|
- switch( zFunk->funkSichtbar )
|
|
|
- {
|
|
|
- case 0: // public
|
|
|
- if( !zVorObj )
|
|
|
- return zObj->startFunktion( zFunk->funcId, parameter );
|
|
|
- break;
|
|
|
- case 1: // public in Klasse
|
|
|
- if( zVorObj )
|
|
|
- return zVorObj->startFunktion( zFunk->funcId, 0, parameter );
|
|
|
- else if( zKI )
|
|
|
- return zKI->startFunktion( zFunk->funcId, 1, parameter );
|
|
|
- break;
|
|
|
- case 2: // privat in Klasse
|
|
|
- if( zKI && !zVorObj )
|
|
|
- return zKI->startFunktion( zFunk->funcId, 1, parameter );
|
|
|
- break;
|
|
|
- }
|
|
|
- parameter->release();
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
+ if (!zFunk)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ RCArray< KSGSVariable >* parameter = new RCArray< KSGSVariable >();
|
|
|
+ int pAnz = zFunk->parameter.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < pAnz; i++)
|
|
|
+ parameter->set(prozessParameter(zFunk->parameter.get(i), zObj, zFI, zKI), i);
|
|
|
+ switch (zFunk->funkSichtbar)
|
|
|
+ {
|
|
|
+ case 0: // public
|
|
|
+ if (!zVorObj)
|
|
|
+ return zObj->startFunktion(zFunk->funcId, parameter);
|
|
|
+ break;
|
|
|
+ case 1: // public in Klasse
|
|
|
+ if (zVorObj)
|
|
|
+ return zVorObj->startFunktion(zFunk->funcId, 0, parameter);
|
|
|
+ else if (zKI)
|
|
|
+ return zKI->startFunktion(zFunk->funcId, 1, parameter);
|
|
|
+ break;
|
|
|
+ case 2: // privat in Klasse
|
|
|
+ if (zKI && !zVorObj)
|
|
|
+ return zKI->startFunktion(zFunk->funcId, 1, parameter);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ parameter->release();
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-KSGSVariable *KSGSBefehl::prozessMember( KSGSVariable *zVorObj, KSGSBefehlMember *zMem, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
|
|
|
+KSGSVariable* KSGSBefehl::prozessMember(KSGSVariable* zVorObj, KSGSBefehlMember* zMem, KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI)
|
|
|
{
|
|
|
- if( !zMem )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- switch( zMem->typ )
|
|
|
- {
|
|
|
- case KSGSBefehlMember::BEFEHL:
|
|
|
- if( !zVorObj && zMem->bef )
|
|
|
- return zMem->bef->execute( zObj, zFI, zKI );
|
|
|
- break;
|
|
|
- case KSGSBefehlMember::FUNKTION:
|
|
|
- if( zMem->funk )
|
|
|
- return prozessFunktion( zVorObj, zMem->funk, zObj, zFI, zKI );
|
|
|
- break;
|
|
|
- case KSGSBefehlMember::VARIABLE:
|
|
|
- if( zMem->var )
|
|
|
- return prozessVariable( zVorObj, zMem->var, zObj, zFI, zKI );
|
|
|
- break;
|
|
|
- }
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
+ if (!zMem)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ switch (zMem->typ)
|
|
|
+ {
|
|
|
+ case KSGSBefehlMember::BEFEHL:
|
|
|
+ if (!zVorObj && zMem->bef)
|
|
|
+ return zMem->bef->execute(zObj, zFI, zKI);
|
|
|
+ break;
|
|
|
+ case KSGSBefehlMember::FUNKTION:
|
|
|
+ if (zMem->funk)
|
|
|
+ return prozessFunktion(zVorObj, zMem->funk, zObj, zFI, zKI);
|
|
|
+ break;
|
|
|
+ case KSGSBefehlMember::VARIABLE:
|
|
|
+ if (zMem->var)
|
|
|
+ return prozessVariable(zVorObj, zMem->var, zObj, zFI, zKI);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-KSGSVariable *KSGSBefehl::prozessParameter( KSGSBefehlParameter *zParam, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
|
|
|
+KSGSVariable* KSGSBefehl::prozessParameter(KSGSBefehlParameter* zParam, KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI)
|
|
|
{
|
|
|
- if( !zParam )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- switch( zParam->typ )
|
|
|
- {
|
|
|
- case KSGSBefehlParameter::WERT:
|
|
|
- if( zParam->wert.getLength() )
|
|
|
- {
|
|
|
- if( !zParam->wert.positionVon( "0x" ) )
|
|
|
- return new KSGSIntKlasse( zObj, zParam->wert );
|
|
|
- if( zParam->wert.istGleich( "true" ) )
|
|
|
- return new KSGSBoolKlasse( zObj, 1 );
|
|
|
- if( zParam->wert.istGleich( "false" ) )
|
|
|
- return new KSGSBoolKlasse( zObj, 0 );
|
|
|
- int anz = zParam->wert.getLength();
|
|
|
- bool p = 0;
|
|
|
- bool num = 1;
|
|
|
- bool m = 0;
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- num &= ( zParam->wert[ i ] >= '0' && zParam->wert[ i ] <= '9' ) || zParam->wert[ i ] == '.' || zParam->wert[ i ] == '-';
|
|
|
- if( zParam->wert[ i ] == '.' )
|
|
|
- {
|
|
|
- if( p )
|
|
|
- num = 0;
|
|
|
- p = 1;
|
|
|
- }
|
|
|
- if( zParam->wert[ i ] == '-' )
|
|
|
- {
|
|
|
- if( m )
|
|
|
- num = 0;
|
|
|
- m = 1;
|
|
|
- }
|
|
|
- }
|
|
|
- if( num )
|
|
|
- {
|
|
|
- if( p )
|
|
|
- return new KSGSDoubleKlasse( zObj, zParam->wert );
|
|
|
- else
|
|
|
- return new KSGSIntKlasse( zObj, zParam->wert );
|
|
|
- }
|
|
|
- if( !zParam->wert.positionVon( '"' ) && zParam->wert.positionVon( '"', zParam->wert.anzahlVon( '"' ) - 1 ) == anz - 1 )
|
|
|
- {
|
|
|
- Text *txt = zParam->wert.getTeilText( 1, anz - 1 );
|
|
|
- KSGSVariable *ret = new KSGSTextKlasse( zObj, *txt );
|
|
|
- txt->release();
|
|
|
- return ret;
|
|
|
- }
|
|
|
- if( anz == 3 && zParam->wert[ 0 ] == '\'' && zParam->wert[ 2 ] == '\'' )
|
|
|
- return new KSGSIntKlasse( zObj, zParam->wert[ 1 ] );
|
|
|
- }
|
|
|
- break;
|
|
|
- case KSGSBefehlParameter::OBJEKT:
|
|
|
- if( zParam->objekt.getEintragAnzahl() )
|
|
|
- {
|
|
|
- KSGSVariable *v = 0;
|
|
|
- int anz = zParam->objekt.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- KSGSVariable *tmp = prozessMember( v, zParam->objekt.get( i ), zObj, zFI, zKI );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- v = tmp;
|
|
|
- }
|
|
|
- return v;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
+ if (!zParam)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ switch (zParam->typ)
|
|
|
+ {
|
|
|
+ case KSGSBefehlParameter::WERT:
|
|
|
+ if (zParam->wert.getLength())
|
|
|
+ {
|
|
|
+ if (!zParam->wert.positionVon("0x"))
|
|
|
+ return new KSGSIntKlasse(zObj, (int)zParam->wert);
|
|
|
+ if (zParam->wert.istGleich("true"))
|
|
|
+ return new KSGSBoolKlasse(zObj, 1);
|
|
|
+ if (zParam->wert.istGleich("false"))
|
|
|
+ return new KSGSBoolKlasse(zObj, 0);
|
|
|
+ int anz = zParam->wert.getLength();
|
|
|
+ bool p = 0;
|
|
|
+ bool num = 1;
|
|
|
+ bool m = 0;
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ num &= (zParam->wert[i] >= '0' && zParam->wert[i] <= '9') || zParam->wert[i] == '.' || zParam->wert[i] == '-';
|
|
|
+ if (zParam->wert[i] == '.')
|
|
|
+ {
|
|
|
+ if (p)
|
|
|
+ num = 0;
|
|
|
+ p = 1;
|
|
|
+ }
|
|
|
+ if (zParam->wert[i] == '-')
|
|
|
+ {
|
|
|
+ if (m)
|
|
|
+ num = 0;
|
|
|
+ m = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (num)
|
|
|
+ {
|
|
|
+ if (p)
|
|
|
+ return new KSGSDoubleKlasse(zObj, (double)zParam->wert);
|
|
|
+ else
|
|
|
+ return new KSGSIntKlasse(zObj, (int)zParam->wert);
|
|
|
+ }
|
|
|
+ if (!zParam->wert.positionVon('"') && zParam->wert.positionVon('"', zParam->wert.anzahlVon('"') - 1) == anz - 1)
|
|
|
+ {
|
|
|
+ Text* txt = zParam->wert.getTeilText(1, anz - 1);
|
|
|
+ KSGSVariable* ret = new KSGSTextKlasse(zObj, *txt);
|
|
|
+ txt->release();
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+ if (anz == 3 && zParam->wert[0] == '\'' && zParam->wert[2] == '\'')
|
|
|
+ return new KSGSIntKlasse(zObj, zParam->wert[1]);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case KSGSBefehlParameter::OBJEKT:
|
|
|
+ if (zParam->objekt.getEintragAnzahl())
|
|
|
+ {
|
|
|
+ KSGSVariable* v = 0;
|
|
|
+ int anz = zParam->objekt.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ KSGSVariable* tmp = prozessMember(v, zParam->objekt.get(i), zObj, zFI, zKI);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ v = tmp;
|
|
|
+ }
|
|
|
+ return v;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-KSGSVariable *KSGSBefehl::prozessErstell( KSGSBefehlErstell *zErst, KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI )
|
|
|
+KSGSVariable* KSGSBefehl::prozessErstell(KSGSBefehlErstell* zErst, KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI)
|
|
|
{
|
|
|
- if( !zErst )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- KSGSVariable *ret = 0;
|
|
|
- if( zErst->param )
|
|
|
- ret = prozessParameter( zErst->param, zObj, zFI, zKI );
|
|
|
- if( !ret )
|
|
|
- {
|
|
|
- KSGSVariableDef def = { zErst->typId, zErst->id, 3, "" };
|
|
|
- ret = KSGSKlasseInstanz::erstellVariable( zObj, &def );
|
|
|
- }
|
|
|
- if( !ret )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if( ret->getTyp() != zErst->typId )
|
|
|
- {
|
|
|
- KSGSVariable *tmp = ret->umwandelnIn( zErst->typId );
|
|
|
- ret->release();
|
|
|
- ret = tmp;
|
|
|
- }
|
|
|
- zFI->setVariable( zErst->id, dynamic_cast<KSGSVariable *>( ret->getThis() ) );
|
|
|
- return ret;
|
|
|
+ if (!zErst)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ KSGSVariable* ret = 0;
|
|
|
+ if (zErst->param)
|
|
|
+ ret = prozessParameter(zErst->param, zObj, zFI, zKI);
|
|
|
+ if (!ret)
|
|
|
+ {
|
|
|
+ KSGSVariableDef def = { zErst->typId, zErst->id, 3, "" };
|
|
|
+ ret = KSGSKlasseInstanz::erstellVariable(zObj, &def);
|
|
|
+ }
|
|
|
+ if (!ret)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (ret->getTyp() != zErst->typId)
|
|
|
+ {
|
|
|
+ KSGSVariable* tmp = ret->umwandelnIn(zErst->typId);
|
|
|
+ ret->release();
|
|
|
+ ret = tmp;
|
|
|
+ }
|
|
|
+ zFI->setVariable(zErst->id, dynamic_cast<KSGSVariable*>(ret->getThis()));
|
|
|
+ return ret;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSCallBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSCallBefehl::KSGSCallBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::CALL )
|
|
|
+KSGSCallBefehl::KSGSCallBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::CALL)
|
|
|
{
|
|
|
- removeKlammer( &bef->befehl );
|
|
|
- int abschnittAnz = bef->befehl.anzahlVon( '.' ) + 1;
|
|
|
- int *abschnittEnde = new int[ abschnittAnz ];
|
|
|
- for( int i = 0; i < abschnittAnz - 1; i++ )
|
|
|
- abschnittEnde[ i ] = bef->befehl.positionVon( '.', i );
|
|
|
- abschnittEnde[ abschnittAnz - 1 ] = bef->befehl.getLength();
|
|
|
- int vTyp = -1;
|
|
|
- for( int i = 0; i < abschnittAnz; i++ )
|
|
|
- {
|
|
|
- int beg = 0;
|
|
|
- if( i > 0 )
|
|
|
- beg = abschnittEnde[ i - 1 ] + 1;
|
|
|
- int end = abschnittEnde[ i ];
|
|
|
- Text *abschnitt = bef->befehl.getTeilText( beg, end );
|
|
|
- bool b = 0;
|
|
|
- KSGSBefehlMember *mem = new KSGSBefehlMember( zObj, dynamic_cast<Text *>( abschnitt->getThis() ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &vTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, *abschnitt }, zObj );
|
|
|
- abschnitt->release();
|
|
|
- delete mem;
|
|
|
- delete[] abschnittEnde;
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- abschnitt->release();
|
|
|
- objekt.add( mem );
|
|
|
- }
|
|
|
- delete[] abschnittEnde;
|
|
|
- returnTyp = vTyp;
|
|
|
+ removeKlammer(&bef->befehl);
|
|
|
+ int abschnittAnz = bef->befehl.anzahlVon('.') + 1;
|
|
|
+ int* abschnittEnde = new int[abschnittAnz];
|
|
|
+ for (int i = 0; i < abschnittAnz - 1; i++)
|
|
|
+ abschnittEnde[i] = bef->befehl.positionVon('.', i);
|
|
|
+ abschnittEnde[abschnittAnz - 1] = bef->befehl.getLength();
|
|
|
+ int vTyp = -1;
|
|
|
+ for (int i = 0; i < abschnittAnz; i++)
|
|
|
+ {
|
|
|
+ int beg = 0;
|
|
|
+ if (i > 0)
|
|
|
+ beg = abschnittEnde[i - 1] + 1;
|
|
|
+ int end = abschnittEnde[i];
|
|
|
+ Text* abschnitt = bef->befehl.getTeilText(beg, end);
|
|
|
+ bool b = 0;
|
|
|
+ KSGSBefehlMember* mem = new KSGSBefehlMember(zObj, dynamic_cast<Text*>(abschnitt->getThis()), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &vTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, *abschnitt }, zObj);
|
|
|
+ abschnitt->release();
|
|
|
+ delete mem;
|
|
|
+ delete[] abschnittEnde;
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ abschnitt->release();
|
|
|
+ objekt.add(mem);
|
|
|
+ }
|
|
|
+ delete[] abschnittEnde;
|
|
|
+ returnTyp = vTyp;
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSCallBefehl::~KSGSCallBefehl()
|
|
|
{
|
|
|
- int anz = objekt.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- delete objekt.get( i );
|
|
|
+ int anz = objekt.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ delete objekt.get(i);
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSCallBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSCallBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- KSGSVariable *v = 0;
|
|
|
- int anz = objekt.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- KSGSVariable *tmp = prozessMember( v, objekt.get( i ), zObj, zFI, zKI );
|
|
|
- if( v )
|
|
|
- v = (KSGSVariable *)v->release();
|
|
|
- v = tmp;
|
|
|
- }
|
|
|
- return v;
|
|
|
+ KSGSVariable* v = 0;
|
|
|
+ int anz = objekt.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ KSGSVariable* tmp = prozessMember(v, objekt.get(i), zObj, zFI, zKI);
|
|
|
+ if (v)
|
|
|
+ v = (KSGSVariable*)v->release();
|
|
|
+ v = tmp;
|
|
|
+ }
|
|
|
+ return v;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSOperatorBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSOperatorBefehl::KSGSOperatorBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::OPERATOR )
|
|
|
+KSGSOperatorBefehl::KSGSOperatorBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::OPERATOR)
|
|
|
{
|
|
|
- paramL = 0;
|
|
|
- paramR = 0;
|
|
|
- removeKlammer( &bef->befehl );
|
|
|
- operatorId = hatOperator( &bef->befehl );
|
|
|
- if( operatorId < 0 )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- int opLen = 0;
|
|
|
- int opPos = getOperatorPos( &bef->befehl, &opLen );
|
|
|
- Text *links = bef->befehl.getTeilText( 0, opPos );
|
|
|
- bool b = 0;
|
|
|
- paramL = new KSGSBefehlParameter( zObj, links, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &returnTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- Text *rechts = bef->befehl.getTeilText( opPos + opLen );
|
|
|
- b = 0;
|
|
|
- int rTyp = -1;
|
|
|
- paramR = new KSGSBefehlParameter( zObj, rechts, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &rTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- if( operatorId >= 7 && operatorId <= 14 )
|
|
|
- returnTyp = zKT->get( "bool" )->id;
|
|
|
+ paramL = 0;
|
|
|
+ paramR = 0;
|
|
|
+ removeKlammer(&bef->befehl);
|
|
|
+ operatorId = hatOperator(&bef->befehl);
|
|
|
+ if (operatorId < 0)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ int opLen = 0;
|
|
|
+ int opPos = getOperatorPos(&bef->befehl, &opLen);
|
|
|
+ Text* links = bef->befehl.getTeilText(0, opPos);
|
|
|
+ bool b = 0;
|
|
|
+ paramL = new KSGSBefehlParameter(zObj, links, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &returnTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ Text* rechts = bef->befehl.getTeilText(opPos + opLen);
|
|
|
+ b = 0;
|
|
|
+ int rTyp = -1;
|
|
|
+ paramR = new KSGSBefehlParameter(zObj, rechts, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &rTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (operatorId >= 7 && operatorId <= 14)
|
|
|
+ returnTyp = zKT->get("bool")->id;
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSOperatorBefehl::~KSGSOperatorBefehl()
|
|
|
{
|
|
|
- delete paramL;
|
|
|
- delete paramR;
|
|
|
+ delete paramL;
|
|
|
+ delete paramR;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSOperatorBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSOperatorBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- KSGSVariable *l = prozessParameter( paramL, zObj, zFI, zKI );
|
|
|
- if( operatorId == KSGS_O_SET && ( l ? l->getTyp() > KSGS_TYP_MAX : 1 ) )
|
|
|
- {
|
|
|
- if( l )
|
|
|
- l->release();
|
|
|
- if( !paramL || !paramR )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- KSGSVariable *lVObj = 0;
|
|
|
- int vId = 0;
|
|
|
- int vS = 0;
|
|
|
- switch( paramL->typ )
|
|
|
- {
|
|
|
- case KSGSBefehlParameter::WERT:
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- case KSGSBefehlParameter::OBJEKT:
|
|
|
- if( paramL->objekt.getEintragAnzahl() )
|
|
|
- {
|
|
|
- KSGSVariable *v = 0;
|
|
|
- int anz = paramL->objekt.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- lVObj = v ? dynamic_cast<KSGSVariable *>( v->getThis() ) : 0;
|
|
|
- KSGSVariable *tmp = 0;
|
|
|
- switch( paramL->objekt.get( i )->typ )
|
|
|
- {
|
|
|
- case KSGSBefehlMember::BEFEHL:
|
|
|
- if( i == anz - 1 )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if( !v && paramL->objekt.get( i )->bef )
|
|
|
- tmp = paramL->objekt.get( i )->bef->execute( zObj, zFI, zKI );
|
|
|
- break;
|
|
|
- case KSGSBefehlMember::FUNKTION:
|
|
|
- if( i == anz - 1 )
|
|
|
- {
|
|
|
- error( 22, {}, zObj );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if( paramL->objekt.get( i )->funk )
|
|
|
- tmp = prozessFunktion( v, paramL->objekt.get( i )->funk, zObj, zFI, zKI );
|
|
|
- break;
|
|
|
- case KSGSBefehlMember::VARIABLE:
|
|
|
- vId = paramL->objekt.get( i )->var->varId;
|
|
|
- vS = paramL->objekt.get( i )->var->varSichtbar;
|
|
|
- if( paramL->objekt.get( i )->var )
|
|
|
- tmp = prozessVariable( v, paramL->objekt.get( i )->var, zObj, zFI, zKI );
|
|
|
- break;
|
|
|
- }
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- v = tmp;
|
|
|
- }
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- KSGSVariable *r = paramR ? prozessParameter( paramR, zObj, zFI, zKI ) : 0;
|
|
|
- if( !r )
|
|
|
- {
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- error( 22, {}, zObj );
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if( vS == 3 ) // Funktionsvariable
|
|
|
- {
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- zFI->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
|
|
|
- return r;
|
|
|
- }
|
|
|
- else if( !vS ) // Scriptvariable
|
|
|
- {
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- zObj->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
|
|
|
- return r;
|
|
|
- }
|
|
|
- else // Klassenvariable
|
|
|
- {
|
|
|
- if( !lVObj )
|
|
|
- {
|
|
|
- zKI->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
|
|
|
- return r;
|
|
|
- }
|
|
|
- lVObj->setVariable( vId, dynamic_cast<KSGSVariable *>( r->getThis() ) );
|
|
|
- if( lVObj )
|
|
|
- lVObj->release();
|
|
|
- return r;
|
|
|
- }
|
|
|
- }
|
|
|
- if( !l )
|
|
|
- return 0;
|
|
|
- KSGSVariable *r = paramR ? prozessParameter( paramR, zObj, zFI, zKI ) : 0;
|
|
|
- KSGSVariable *ret = l->doOperator( operatorId, r );
|
|
|
- if( l )
|
|
|
- l->release();
|
|
|
- return ret;
|
|
|
+ KSGSVariable* l = prozessParameter(paramL, zObj, zFI, zKI);
|
|
|
+ if (operatorId == KSGS_O_SET && (l ? l->getTyp() > KSGS_TYP_MAX : 1))
|
|
|
+ {
|
|
|
+ if (l)
|
|
|
+ l->release();
|
|
|
+ if (!paramL || !paramR)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ KSGSVariable* lVObj = 0;
|
|
|
+ int vId = 0;
|
|
|
+ int vS = 0;
|
|
|
+ switch (paramL->typ)
|
|
|
+ {
|
|
|
+ case KSGSBefehlParameter::WERT:
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ case KSGSBefehlParameter::OBJEKT:
|
|
|
+ if (paramL->objekt.getEintragAnzahl())
|
|
|
+ {
|
|
|
+ KSGSVariable* v = 0;
|
|
|
+ int anz = paramL->objekt.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ lVObj = v ? dynamic_cast<KSGSVariable*>(v->getThis()) : 0;
|
|
|
+ KSGSVariable* tmp = 0;
|
|
|
+ switch (paramL->objekt.get(i)->typ)
|
|
|
+ {
|
|
|
+ case KSGSBefehlMember::BEFEHL:
|
|
|
+ if (i == anz - 1)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (!v && paramL->objekt.get(i)->bef)
|
|
|
+ tmp = paramL->objekt.get(i)->bef->execute(zObj, zFI, zKI);
|
|
|
+ break;
|
|
|
+ case KSGSBefehlMember::FUNKTION:
|
|
|
+ if (i == anz - 1)
|
|
|
+ {
|
|
|
+ error(22, {}, zObj);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (paramL->objekt.get(i)->funk)
|
|
|
+ tmp = prozessFunktion(v, paramL->objekt.get(i)->funk, zObj, zFI, zKI);
|
|
|
+ break;
|
|
|
+ case KSGSBefehlMember::VARIABLE:
|
|
|
+ vId = paramL->objekt.get(i)->var->varId;
|
|
|
+ vS = paramL->objekt.get(i)->var->varSichtbar;
|
|
|
+ if (paramL->objekt.get(i)->var)
|
|
|
+ tmp = prozessVariable(v, paramL->objekt.get(i)->var, zObj, zFI, zKI);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ v = tmp;
|
|
|
+ }
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ KSGSVariable* r = paramR ? prozessParameter(paramR, zObj, zFI, zKI) : 0;
|
|
|
+ if (!r)
|
|
|
+ {
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ error(22, {}, zObj);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (vS == 3) // Funktionsvariable
|
|
|
+ {
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ zFI->setVariable(vId, dynamic_cast<KSGSVariable*>(r->getThis()));
|
|
|
+ return r;
|
|
|
+ }
|
|
|
+ else if (!vS) // Scriptvariable
|
|
|
+ {
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ zObj->setVariable(vId, dynamic_cast<KSGSVariable*>(r->getThis()));
|
|
|
+ return r;
|
|
|
+ }
|
|
|
+ else // Klassenvariable
|
|
|
+ {
|
|
|
+ if (!lVObj)
|
|
|
+ {
|
|
|
+ zKI->setVariable(vId, dynamic_cast<KSGSVariable*>(r->getThis()));
|
|
|
+ return r;
|
|
|
+ }
|
|
|
+ lVObj->setVariable(vId, dynamic_cast<KSGSVariable*>(r->getThis()));
|
|
|
+ if (lVObj)
|
|
|
+ lVObj->release();
|
|
|
+ return r;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!l)
|
|
|
+ return 0;
|
|
|
+ KSGSVariable* r = paramR ? prozessParameter(paramR, zObj, zFI, zKI) : 0;
|
|
|
+ KSGSVariable* ret = l->doOperator(operatorId, r);
|
|
|
+ if (l)
|
|
|
+ l->release();
|
|
|
+ return ret;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSIfBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSIfBefehl::KSGSIfBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::IF )
|
|
|
+KSGSIfBefehl::KSGSIfBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::IF)
|
|
|
{
|
|
|
- bedingung = 0;
|
|
|
- int bTyp = -1;
|
|
|
- bool b = 0;
|
|
|
- bedingung = new KSGSBefehlParameter( zObj, dynamic_cast<Text *>( bef->befehl.getThis() ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b );
|
|
|
- int anz = bef->listA.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- KSGSLeseBefehl *b = bef->listA.get( i );
|
|
|
- KSGSBefehl *ret = 0;
|
|
|
- switch( b->typ )
|
|
|
- {
|
|
|
- case 0: // call oder operator
|
|
|
- if( 1 )
|
|
|
- {
|
|
|
- removeKlammer( &b->befehl );
|
|
|
- b->befehl.setSuchGrenzen( '(', ')' );
|
|
|
- if( hatOperator( &b->befehl ) >= 0 )
|
|
|
- ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else
|
|
|
- ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- }
|
|
|
- break;
|
|
|
- case 3: // var
|
|
|
- ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 6: // if
|
|
|
- ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 7: // for
|
|
|
- ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 8: // while
|
|
|
- ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 9: // return
|
|
|
- ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 10: // break
|
|
|
- ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 11: // continue
|
|
|
- ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- }
|
|
|
- if( !ret )
|
|
|
- error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
|
|
|
- if( ret && ret->hatFehler() )
|
|
|
- ret = (KSGSBefehl *)ret->release();
|
|
|
- if( !ret )
|
|
|
- {
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- bTrue.add( ret );
|
|
|
- }
|
|
|
- anz = bef->listB.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- KSGSLeseBefehl *b = bef->listB.get( i );
|
|
|
- KSGSBefehl *ret = 0;
|
|
|
- switch( b->typ )
|
|
|
- {
|
|
|
- case 0: // call oder operator
|
|
|
- if( 1 )
|
|
|
- {
|
|
|
- removeKlammer( &b->befehl );
|
|
|
- b->befehl.setSuchGrenzen( '(', ')' );
|
|
|
- if( hatOperator( &b->befehl ) >= 0 )
|
|
|
- ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else
|
|
|
- ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- }
|
|
|
- break;
|
|
|
- case 3: // var
|
|
|
- ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 6: // if
|
|
|
- ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 7: // for
|
|
|
- ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 8: // while
|
|
|
- ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 9: // return
|
|
|
- ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 10: // break
|
|
|
- ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 11: // continue
|
|
|
- ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- }
|
|
|
- if( !ret )
|
|
|
- error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
|
|
|
- if( ret && ret->hatFehler() )
|
|
|
- ret = (KSGSBefehl *)ret->release();
|
|
|
- if( !ret )
|
|
|
- {
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- bFalse.add( ret );
|
|
|
- }
|
|
|
+ bedingung = 0;
|
|
|
+ int bTyp = -1;
|
|
|
+ bool b = 0;
|
|
|
+ bedingung = new KSGSBefehlParameter(zObj, dynamic_cast<Text*>(bef->befehl.getThis()), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b);
|
|
|
+ int anz = bef->listA.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ KSGSLeseBefehl* b = bef->listA.get(i);
|
|
|
+ KSGSBefehl* ret = 0;
|
|
|
+ switch (b->typ)
|
|
|
+ {
|
|
|
+ case 0: // call oder operator
|
|
|
+ if (1)
|
|
|
+ {
|
|
|
+ removeKlammer(&b->befehl);
|
|
|
+ b->befehl.setSuchGrenzen('(', ')');
|
|
|
+ if (hatOperator(&b->befehl) >= 0)
|
|
|
+ ret = new KSGSOperatorBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else
|
|
|
+ ret = new KSGSCallBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 3: // var
|
|
|
+ ret = new KSGSVariableBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 6: // if
|
|
|
+ ret = new KSGSIfBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 7: // for
|
|
|
+ ret = new KSGSForBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 8: // while
|
|
|
+ ret = new KSGSWhileBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 9: // return
|
|
|
+ ret = new KSGSReturnBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 10: // break
|
|
|
+ ret = new KSGSBreakBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 11: // continue
|
|
|
+ ret = new KSGSContinueBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (!ret)
|
|
|
+ error(13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj);
|
|
|
+ if (ret && ret->hatFehler())
|
|
|
+ ret = (KSGSBefehl*)ret->release();
|
|
|
+ if (!ret)
|
|
|
+ {
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ bTrue.add(ret);
|
|
|
+ }
|
|
|
+ anz = bef->listB.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ KSGSLeseBefehl* b = bef->listB.get(i);
|
|
|
+ KSGSBefehl* ret = 0;
|
|
|
+ switch (b->typ)
|
|
|
+ {
|
|
|
+ case 0: // call oder operator
|
|
|
+ if (1)
|
|
|
+ {
|
|
|
+ removeKlammer(&b->befehl);
|
|
|
+ b->befehl.setSuchGrenzen('(', ')');
|
|
|
+ if (hatOperator(&b->befehl) >= 0)
|
|
|
+ ret = new KSGSOperatorBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else
|
|
|
+ ret = new KSGSCallBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 3: // var
|
|
|
+ ret = new KSGSVariableBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 6: // if
|
|
|
+ ret = new KSGSIfBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 7: // for
|
|
|
+ ret = new KSGSForBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 8: // while
|
|
|
+ ret = new KSGSWhileBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 9: // return
|
|
|
+ ret = new KSGSReturnBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 10: // break
|
|
|
+ ret = new KSGSBreakBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 11: // continue
|
|
|
+ ret = new KSGSContinueBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (!ret)
|
|
|
+ error(13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj);
|
|
|
+ if (ret && ret->hatFehler())
|
|
|
+ ret = (KSGSBefehl*)ret->release();
|
|
|
+ if (!ret)
|
|
|
+ {
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ bFalse.add(ret);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSIfBefehl::~KSGSIfBefehl()
|
|
|
{
|
|
|
- delete bedingung;
|
|
|
+ delete bedingung;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSIfBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSIfBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
|
|
|
- if( !b )
|
|
|
- return 0;
|
|
|
- if( b->getBool() )
|
|
|
- {
|
|
|
- int anz = bTrue.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- while( zFI->getStatus() == 1 ) // pause
|
|
|
- Sleep( 100 );
|
|
|
- if( !zFI->getStatus() ) // return
|
|
|
- break;
|
|
|
- KSGSVariable *v = bTrue.z( i )->execute( zObj, zFI, zKI );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- int anz = bFalse.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- while( zFI->getStatus() == 1 ) // pause
|
|
|
- Sleep( 100 );
|
|
|
- if( !zFI->getStatus() ) // return
|
|
|
- break;
|
|
|
- KSGSVariable *v = bFalse.z( i )->execute( zObj, zFI, zKI );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- }
|
|
|
- }
|
|
|
- b->release();
|
|
|
- return 0;
|
|
|
+ KSGSVariable* b = prozessParameter(bedingung, zObj, zFI, zKI);
|
|
|
+ if (!b)
|
|
|
+ return 0;
|
|
|
+ if (b->getBool())
|
|
|
+ {
|
|
|
+ int anz = bTrue.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ while (zFI->getStatus() == 1) // pause
|
|
|
+ Sleep(100);
|
|
|
+ if (!zFI->getStatus()) // return
|
|
|
+ break;
|
|
|
+ KSGSVariable* v = bTrue.z(i)->execute(zObj, zFI, zKI);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ int anz = bFalse.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ while (zFI->getStatus() == 1) // pause
|
|
|
+ Sleep(100);
|
|
|
+ if (!zFI->getStatus()) // return
|
|
|
+ break;
|
|
|
+ KSGSVariable* v = bFalse.z(i)->execute(zObj, zFI, zKI);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ b->release();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSForBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSForBefehl::KSGSForBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::FOR )
|
|
|
+KSGSForBefehl::KSGSForBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::FOR)
|
|
|
{
|
|
|
- links = 0;
|
|
|
- rechts = 0;
|
|
|
- bedingung = 0;
|
|
|
- Text klammer = bef->befehl.getText();
|
|
|
- klammer.setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( &klammer );
|
|
|
- if( klammer.anzahlVon( ';' ) != 2 )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, klammer }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- Text *l = klammer.getTeilText( 0, klammer.positionVon( ';' ) );
|
|
|
- l->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( l );
|
|
|
- KSGSLeseBefehl *b = new KSGSLeseBefehl();
|
|
|
- b->debug.datei = bef->debug.datei.getText();
|
|
|
- b->debug.zeile = bef->debug.zeile;
|
|
|
- b->befehl = l->getText();
|
|
|
- l->release();
|
|
|
- if( !b->befehl.positionVon( "var" ) )
|
|
|
- links = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else if( hatOperator( &b->befehl ) >= 0 )
|
|
|
- links = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else if( b->befehl.getLength() )
|
|
|
- links = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- delete b;
|
|
|
- if( links && links->hatFehler() )
|
|
|
- {
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- Text *bed = klammer.getTeilText( klammer.positionVon( ';' ) + 1, klammer.positionVon( ';', 1 ) );
|
|
|
- bed->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( bed );
|
|
|
- if( bed->getLength() )
|
|
|
- {
|
|
|
- int bTyp = -1;
|
|
|
- bool b = 0;
|
|
|
- bedingung = new KSGSBefehlParameter( zObj, bed, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, klammer }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- bed->release();
|
|
|
- Text *r = klammer.getTeilText( klammer.positionVon( ';', 1 ) + 1 );
|
|
|
- r->setSuchGrenzen( '(', ')' );
|
|
|
- removeKlammer( r );
|
|
|
- b = new KSGSLeseBefehl();
|
|
|
- b->debug.datei = bef->debug.datei.getText();
|
|
|
- b->debug.zeile = bef->debug.zeile;
|
|
|
- b->befehl = r->getText();
|
|
|
- r->release();
|
|
|
- if( hatOperator( &b->befehl ) >= 0 )
|
|
|
- rechts = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else if( b->befehl.getLength() )
|
|
|
- rechts = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- delete b;
|
|
|
- if( rechts && rechts->hatFehler() )
|
|
|
- {
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- int anz = bef->listA.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- KSGSLeseBefehl *b = bef->listA.get( i );
|
|
|
- KSGSBefehl *ret = 0;
|
|
|
- switch( b->typ )
|
|
|
- {
|
|
|
- case 0: // call oder operator
|
|
|
- if( 1 )
|
|
|
- {
|
|
|
- removeKlammer( &b->befehl );
|
|
|
- b->befehl.setSuchGrenzen( '(', ')' );
|
|
|
- if( hatOperator( &b->befehl ) >= 0 )
|
|
|
- ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else
|
|
|
- ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- }
|
|
|
- break;
|
|
|
- case 3: // var
|
|
|
- ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 6: // if
|
|
|
- ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 7: // for
|
|
|
- ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 8: // while
|
|
|
- ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 9: // return
|
|
|
- ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 10: // break
|
|
|
- ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 11: // continue
|
|
|
- ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- }
|
|
|
- if( !ret )
|
|
|
- error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
|
|
|
- if( ret && ret->hatFehler() )
|
|
|
- ret = (KSGSBefehl *)ret->release();
|
|
|
- if( !ret )
|
|
|
- {
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- schleife.add( ret );
|
|
|
- }
|
|
|
+ links = 0;
|
|
|
+ rechts = 0;
|
|
|
+ bedingung = 0;
|
|
|
+ Text klammer = bef->befehl.getText();
|
|
|
+ klammer.setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(&klammer);
|
|
|
+ if (klammer.anzahlVon(';') != 2)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, klammer }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ Text* l = klammer.getTeilText(0, klammer.positionVon(';'));
|
|
|
+ l->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(l);
|
|
|
+ KSGSLeseBefehl* b = new KSGSLeseBefehl();
|
|
|
+ b->debug.datei = bef->debug.datei.getText();
|
|
|
+ b->debug.zeile = bef->debug.zeile;
|
|
|
+ b->befehl = l->getText();
|
|
|
+ l->release();
|
|
|
+ if (!b->befehl.positionVon("var"))
|
|
|
+ links = new KSGSVariableBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else if (hatOperator(&b->befehl) >= 0)
|
|
|
+ links = new KSGSOperatorBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else if (b->befehl.getLength())
|
|
|
+ links = new KSGSCallBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ delete b;
|
|
|
+ if (links && links->hatFehler())
|
|
|
+ {
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ Text* bed = klammer.getTeilText(klammer.positionVon(';') + 1, klammer.positionVon(';', 1));
|
|
|
+ bed->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(bed);
|
|
|
+ if (bed->getLength())
|
|
|
+ {
|
|
|
+ int bTyp = -1;
|
|
|
+ bool b = 0;
|
|
|
+ bedingung = new KSGSBefehlParameter(zObj, bed, &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, klammer }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ bed->release();
|
|
|
+ Text* r = klammer.getTeilText(klammer.positionVon(';', 1) + 1);
|
|
|
+ r->setSuchGrenzen('(', ')');
|
|
|
+ removeKlammer(r);
|
|
|
+ b = new KSGSLeseBefehl();
|
|
|
+ b->debug.datei = bef->debug.datei.getText();
|
|
|
+ b->debug.zeile = bef->debug.zeile;
|
|
|
+ b->befehl = r->getText();
|
|
|
+ r->release();
|
|
|
+ if (hatOperator(&b->befehl) >= 0)
|
|
|
+ rechts = new KSGSOperatorBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else if (b->befehl.getLength())
|
|
|
+ rechts = new KSGSCallBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ delete b;
|
|
|
+ if (rechts && rechts->hatFehler())
|
|
|
+ {
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ int anz = bef->listA.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ KSGSLeseBefehl* b = bef->listA.get(i);
|
|
|
+ KSGSBefehl* ret = 0;
|
|
|
+ switch (b->typ)
|
|
|
+ {
|
|
|
+ case 0: // call oder operator
|
|
|
+ if (1)
|
|
|
+ {
|
|
|
+ removeKlammer(&b->befehl);
|
|
|
+ b->befehl.setSuchGrenzen('(', ')');
|
|
|
+ if (hatOperator(&b->befehl) >= 0)
|
|
|
+ ret = new KSGSOperatorBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else
|
|
|
+ ret = new KSGSCallBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 3: // var
|
|
|
+ ret = new KSGSVariableBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 6: // if
|
|
|
+ ret = new KSGSIfBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 7: // for
|
|
|
+ ret = new KSGSForBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 8: // while
|
|
|
+ ret = new KSGSWhileBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 9: // return
|
|
|
+ ret = new KSGSReturnBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 10: // break
|
|
|
+ ret = new KSGSBreakBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 11: // continue
|
|
|
+ ret = new KSGSContinueBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (!ret)
|
|
|
+ error(13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj);
|
|
|
+ if (ret && ret->hatFehler())
|
|
|
+ ret = (KSGSBefehl*)ret->release();
|
|
|
+ if (!ret)
|
|
|
+ {
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ schleife.add(ret);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSForBefehl::~KSGSForBefehl()
|
|
|
{
|
|
|
- if( links )
|
|
|
- links->release();
|
|
|
- if( rechts )
|
|
|
- rechts->release();
|
|
|
- delete bedingung;
|
|
|
+ if (links)
|
|
|
+ links->release();
|
|
|
+ if (rechts)
|
|
|
+ rechts->release();
|
|
|
+ delete bedingung;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSForBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSForBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- KSGSVariable *l = links ? links->execute( zObj, zFI, zKI ) : 0;
|
|
|
- if( l )
|
|
|
- l->release();
|
|
|
- KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
|
|
|
- if( !b )
|
|
|
- return 0;
|
|
|
- int anz = schleife.getEintragAnzahl();
|
|
|
- while( b->getBool() )
|
|
|
- {
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- while( zFI->getStatus() == 1 ) // pause
|
|
|
- Sleep( 100 );
|
|
|
- if( !zFI->getStatus() ) // return
|
|
|
- break;
|
|
|
- if( zFI->getStatus() == 2 ) // continue
|
|
|
- break;
|
|
|
- KSGSVariable *v = schleife.z( i )->execute( zObj, zFI, zKI );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- }
|
|
|
- if( zFI->getStatus() == 3 ) // break
|
|
|
- break;
|
|
|
- while( zFI->getStatus() == 1 ) // pause
|
|
|
- Sleep( 100 );
|
|
|
- if( !zFI->getStatus() ) // return
|
|
|
- break;
|
|
|
- if( !anz )
|
|
|
- Sleep( 100 );
|
|
|
- KSGSVariable *v = rechts ? rechts->execute( zObj, zFI, zKI ) : 0;
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- if( b )
|
|
|
- b->release();
|
|
|
- b = prozessParameter( bedingung, zObj, zFI, zKI );
|
|
|
- if( !b )
|
|
|
- return 0;
|
|
|
- }
|
|
|
- b->release();
|
|
|
- return 0;
|
|
|
+ KSGSVariable* l = links ? links->execute(zObj, zFI, zKI) : 0;
|
|
|
+ if (l)
|
|
|
+ l->release();
|
|
|
+ KSGSVariable* b = prozessParameter(bedingung, zObj, zFI, zKI);
|
|
|
+ if (!b)
|
|
|
+ return 0;
|
|
|
+ int anz = schleife.getEintragAnzahl();
|
|
|
+ while (b->getBool())
|
|
|
+ {
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ while (zFI->getStatus() == 1) // pause
|
|
|
+ Sleep(100);
|
|
|
+ if (!zFI->getStatus()) // return
|
|
|
+ break;
|
|
|
+ if (zFI->getStatus() == 2) // continue
|
|
|
+ break;
|
|
|
+ KSGSVariable* v = schleife.z(i)->execute(zObj, zFI, zKI);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ }
|
|
|
+ if (zFI->getStatus() == 3) // break
|
|
|
+ break;
|
|
|
+ while (zFI->getStatus() == 1) // pause
|
|
|
+ Sleep(100);
|
|
|
+ if (!zFI->getStatus()) // return
|
|
|
+ break;
|
|
|
+ if (!anz)
|
|
|
+ Sleep(100);
|
|
|
+ KSGSVariable* v = rechts ? rechts->execute(zObj, zFI, zKI) : 0;
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ if (b)
|
|
|
+ b->release();
|
|
|
+ b = prozessParameter(bedingung, zObj, zFI, zKI);
|
|
|
+ if (!b)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ b->release();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSWhileBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSWhileBefehl::KSGSWhileBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::WHILE )
|
|
|
+KSGSWhileBefehl::KSGSWhileBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::WHILE)
|
|
|
{
|
|
|
- bedingung = 0;
|
|
|
- int bTyp = -1;
|
|
|
- bool b = 0;
|
|
|
- bedingung = new KSGSBefehlParameter( zObj, dynamic_cast<Text *>( bef->befehl.getThis() ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b );
|
|
|
- int anz = bef->listA.getEintragAnzahl();
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- KSGSLeseBefehl *b = bef->listA.get( i );
|
|
|
- KSGSBefehl *ret = 0;
|
|
|
- switch( b->typ )
|
|
|
- {
|
|
|
- case 0: // call oder operator
|
|
|
- if( 1 )
|
|
|
- {
|
|
|
- removeKlammer( &b->befehl );
|
|
|
- b->befehl.setSuchGrenzen( '(', ')' );
|
|
|
- if( hatOperator( &b->befehl ) >= 0 )
|
|
|
- ret = new KSGSOperatorBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- else
|
|
|
- ret = new KSGSCallBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- }
|
|
|
- break;
|
|
|
- case 3: // var
|
|
|
- ret = new KSGSVariableBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 6: // if
|
|
|
- ret = new KSGSIfBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 7: // for
|
|
|
- ret = new KSGSForBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 8: // while
|
|
|
- ret = new KSGSWhileBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 9: // return
|
|
|
- ret = new KSGSReturnBefehl( zObj, b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 10: // break
|
|
|
- ret = new KSGSBreakBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- case 11: // continue
|
|
|
- ret = new KSGSContinueBefehl( b, zKT, zFT, zVT, klassName, funktionName );
|
|
|
- break;
|
|
|
- }
|
|
|
- if( !ret )
|
|
|
- error( 13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj );
|
|
|
- if( ret && ret->hatFehler() )
|
|
|
- ret = (KSGSBefehl *)ret->release();
|
|
|
- if( !ret )
|
|
|
- {
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- schleife.add( ret );
|
|
|
- }
|
|
|
+ bedingung = 0;
|
|
|
+ int bTyp = -1;
|
|
|
+ bool b = 0;
|
|
|
+ bedingung = new KSGSBefehlParameter(zObj, dynamic_cast<Text*>(bef->befehl.getThis()), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &bTyp, &b);
|
|
|
+ int anz = bef->listA.getEintragAnzahl();
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ KSGSLeseBefehl* b = bef->listA.get(i);
|
|
|
+ KSGSBefehl* ret = 0;
|
|
|
+ switch (b->typ)
|
|
|
+ {
|
|
|
+ case 0: // call oder operator
|
|
|
+ if (1)
|
|
|
+ {
|
|
|
+ removeKlammer(&b->befehl);
|
|
|
+ b->befehl.setSuchGrenzen('(', ')');
|
|
|
+ if (hatOperator(&b->befehl) >= 0)
|
|
|
+ ret = new KSGSOperatorBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ else
|
|
|
+ ret = new KSGSCallBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 3: // var
|
|
|
+ ret = new KSGSVariableBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 6: // if
|
|
|
+ ret = new KSGSIfBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 7: // for
|
|
|
+ ret = new KSGSForBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 8: // while
|
|
|
+ ret = new KSGSWhileBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 9: // return
|
|
|
+ ret = new KSGSReturnBefehl(zObj, b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 10: // break
|
|
|
+ ret = new KSGSBreakBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ case 11: // continue
|
|
|
+ ret = new KSGSContinueBefehl(b, zKT, zFT, zVT, klassName, funktionName);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (!ret)
|
|
|
+ error(13, { b->debug.datei, Text() += b->debug.zeile, b->befehl }, zObj);
|
|
|
+ if (ret && ret->hatFehler())
|
|
|
+ ret = (KSGSBefehl*)ret->release();
|
|
|
+ if (!ret)
|
|
|
+ {
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ schleife.add(ret);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSWhileBefehl::~KSGSWhileBefehl()
|
|
|
{
|
|
|
- delete bedingung;
|
|
|
+ delete bedingung;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSWhileBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSWhileBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- KSGSVariable *b = prozessParameter( bedingung, zObj, zFI, zKI );
|
|
|
- if( !b )
|
|
|
- return 0;
|
|
|
- int anz = schleife.getEintragAnzahl();
|
|
|
- while( b->getBool() )
|
|
|
- {
|
|
|
- for( int i = 0; i < anz; i++ )
|
|
|
- {
|
|
|
- while( zFI->getStatus() == 1 ) // pause
|
|
|
- Sleep( 100 );
|
|
|
- if( !zFI->getStatus() ) // return
|
|
|
- break;
|
|
|
- if( zFI->getStatus() == 2 ) // continue
|
|
|
- break;
|
|
|
- KSGSVariable *v = schleife.z( i )->execute( zObj, zFI, zKI );
|
|
|
- if( v )
|
|
|
- v->release();
|
|
|
- }
|
|
|
- if( zFI->getStatus() == 3 ) // break
|
|
|
- break;
|
|
|
- while( zFI->getStatus() == 1 ) // pause
|
|
|
- Sleep( 100 );
|
|
|
- if( !zFI->getStatus() ) // return
|
|
|
- break;
|
|
|
- if( !anz )
|
|
|
- Sleep( 100 );
|
|
|
- if( b )
|
|
|
- b->release();
|
|
|
- b = prozessParameter( bedingung, zObj, zFI, zKI );
|
|
|
- if( !b )
|
|
|
- return 0;
|
|
|
- }
|
|
|
- b->release();
|
|
|
- return 0;
|
|
|
+ KSGSVariable* b = prozessParameter(bedingung, zObj, zFI, zKI);
|
|
|
+ if (!b)
|
|
|
+ return 0;
|
|
|
+ int anz = schleife.getEintragAnzahl();
|
|
|
+ while (b->getBool())
|
|
|
+ {
|
|
|
+ for (int i = 0; i < anz; i++)
|
|
|
+ {
|
|
|
+ while (zFI->getStatus() == 1) // pause
|
|
|
+ Sleep(100);
|
|
|
+ if (!zFI->getStatus()) // return
|
|
|
+ break;
|
|
|
+ if (zFI->getStatus() == 2) // continue
|
|
|
+ break;
|
|
|
+ KSGSVariable* v = schleife.z(i)->execute(zObj, zFI, zKI);
|
|
|
+ if (v)
|
|
|
+ v->release();
|
|
|
+ }
|
|
|
+ if (zFI->getStatus() == 3) // break
|
|
|
+ break;
|
|
|
+ while (zFI->getStatus() == 1) // pause
|
|
|
+ Sleep(100);
|
|
|
+ if (!zFI->getStatus()) // return
|
|
|
+ break;
|
|
|
+ if (!anz)
|
|
|
+ Sleep(100);
|
|
|
+ if (b)
|
|
|
+ b->release();
|
|
|
+ b = prozessParameter(bedingung, zObj, zFI, zKI);
|
|
|
+ if (!b)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ b->release();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSReturnBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSReturnBefehl::KSGSReturnBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::RETURN )
|
|
|
+KSGSReturnBefehl::KSGSReturnBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::RETURN)
|
|
|
{
|
|
|
- param = 0;
|
|
|
- if( bef->befehl.positionVon( "return" ) != 0 )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- bool b = 0;
|
|
|
- param = new KSGSBefehlParameter( zObj, bef->befehl.getTeilText( 6 ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &returnTyp, &b );
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- delete param;
|
|
|
- param = 0;
|
|
|
- }
|
|
|
+ param = 0;
|
|
|
+ if (bef->befehl.positionVon("return") != 0)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ bool b = 0;
|
|
|
+ param = new KSGSBefehlParameter(zObj, bef->befehl.getTeilText(6), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &returnTyp, &b);
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ delete param;
|
|
|
+ param = 0;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSReturnBefehl::~KSGSReturnBefehl()
|
|
|
{
|
|
|
- delete param;
|
|
|
+ delete param;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSReturnBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSReturnBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- KSGSVariable *v = param ? prozessParameter( param, zObj, zFI, zKI ) : 0;
|
|
|
- if( v )
|
|
|
- zFI->setReturnVariable( v );
|
|
|
- zFI->setEnde();
|
|
|
- return 0;
|
|
|
+ KSGSVariable* v = param ? prozessParameter(param, zObj, zFI, zKI) : 0;
|
|
|
+ if (v)
|
|
|
+ zFI->setReturnVariable(v);
|
|
|
+ zFI->setEnde();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSBreakBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSBreakBefehl::KSGSBreakBefehl( KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::BREAK )
|
|
|
+KSGSBreakBefehl::KSGSBreakBefehl(KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::BREAK)
|
|
|
{}
|
|
|
|
|
|
// Destruktor
|
|
@@ -1480,18 +1480,18 @@ KSGSBreakBefehl::~KSGSBreakBefehl()
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSBreakBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSBreakBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- zFI->setBreak();
|
|
|
- return 0;
|
|
|
+ zFI->setBreak();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSContinueBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSContinueBefehl::KSGSContinueBefehl( KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::CONTINUE )
|
|
|
+KSGSContinueBefehl::KSGSContinueBefehl(KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::CONTINUE)
|
|
|
{}
|
|
|
|
|
|
// Destruktor
|
|
@@ -1501,45 +1501,45 @@ KSGSContinueBefehl::~KSGSContinueBefehl()
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSContinueBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSContinueBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- zFI->setContinue();
|
|
|
- return 0;
|
|
|
+ zFI->setContinue();
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der KSGSVariableBefehl Klasse aus KSGSBefehl.h
|
|
|
// Konstruktor
|
|
|
-KSGSVariableBefehl::KSGSVariableBefehl( KSGScriptProcessor *zObj, KSGSLeseBefehl *bef, KSGSCompKlassTable *zKT, KSGSCompFuncTable *zFT,
|
|
|
- KSGSCompVarTable *zVT, const char *klassName, const char *funktionName )
|
|
|
- : KSGSBefehl( Typ::VARIABLE )
|
|
|
+KSGSVariableBefehl::KSGSVariableBefehl(KSGScriptProcessor* zObj, KSGSLeseBefehl* bef, KSGSCompKlassTable* zKT, KSGSCompFuncTable* zFT,
|
|
|
+ KSGSCompVarTable* zVT, const char* klassName, const char* funktionName)
|
|
|
+ : KSGSBefehl(Typ::VARIABLE)
|
|
|
{
|
|
|
- erstell = 0;
|
|
|
- if( bef->befehl.positionVon( "var" ) != 0 )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- bool b = 0;
|
|
|
- erstell = new KSGSBefehlErstell( zObj, bef->befehl.getTeilText( 3 ), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &b );
|
|
|
- returnTyp = erstell->typId;
|
|
|
- if( !b )
|
|
|
- {
|
|
|
- error( 13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj );
|
|
|
- fehler = 1;
|
|
|
- return;
|
|
|
- }
|
|
|
+ erstell = 0;
|
|
|
+ if (bef->befehl.positionVon("var") != 0)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ bool b = 0;
|
|
|
+ erstell = new KSGSBefehlErstell(zObj, bef->befehl.getTeilText(3), &bef->debug, zKT, zFT, zVT, klassName, funktionName, &b);
|
|
|
+ returnTyp = erstell->typId;
|
|
|
+ if (!b)
|
|
|
+ {
|
|
|
+ error(13, { bef->debug.datei, Text() += bef->debug.zeile, bef->befehl }, zObj);
|
|
|
+ fehler = 1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
KSGSVariableBefehl::~KSGSVariableBefehl()
|
|
|
{
|
|
|
- delete erstell;
|
|
|
+ delete erstell;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-KSGSVariable *KSGSVariableBefehl::execute( KSGScriptProcessor *zObj, KSGSFunktionInstanz *zFI, KSGSVariable *zKI ) const
|
|
|
+KSGSVariable* KSGSVariableBefehl::execute(KSGScriptProcessor* zObj, KSGSFunktionInstanz* zFI, KSGSVariable* zKI) const
|
|
|
{
|
|
|
- return prozessErstell( erstell, zObj, zFI, zKI );
|
|
|
+ return prozessErstell(erstell, zObj, zFI, zKI);
|
|
|
}
|