IF-Schleife Programmieren

[paule22]

Hallo Programmers,

mal wieder ne doofe Frage:

Wie kann ich eine IF-Schleife programmieren. (SourceCode wäre sinnvoll).

Zum Inhalt:

in einer Datei lese ich Zeichen für Zeichen aus und setze die ausgelesenen Zeichen zu token zusammen. Nun kommt folgender Ausdruck:

if wert = 4;

if wert_zaehler = 5;

? "richtig.";

endif

if wert = 3;

? "r2";

endif

? "Wert beträgt drei (3) -> " + wert;

endif

Vielen Dank für Hilfe.

[hades]

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR>Original erstellt von paule22:

<STRONG>Wie kann ich eine IF-Schleife programmieren.

</STRONG>

[paule22]

Hallo

ich glaub du hast die Frage falsch verstanden?

Ich baue gerade einen eigenen Compiler in der der Ausdruck

IF expr = wert

IF expr2 = wert2

ENDIF

ENDIF

vorkommt.

IF und ENDIF werden als token ausgelesen.

expr als Expression/Variable behandelt, wert gibt den Bedingungswert wieder.

Leider ist es mir bis dato nicht gelungen einen vernüftigen IF-Handler-Procedure zu schreiben.

Müsste doch das einfachste der Welt sein ??????

Also weiter Vielen Dank für Hilfe ....

[paule22]

der code dazu schaut in etwa wie folgt aus ...

int handle_procedure(void)

{

TStringList *local_variables = new TStringList();

AnsiString saved_token;

static int if_rec = 0;

int rec = 0;

for (;

{

next_token:

int code = get_token();

switch (code)

{

case DT_FORM:

{

switch (lex())

{

case POINT_TOKEN:

{

if (handle_formstatement() == RET_FAIL)

return RET_FAIL;

}

break;

default:

return fatal("Hier wird ein Punkt (.) erwartet.");

break;

}

}

break;

case DT_PRINT:

{

dt_printgoto:

AnsiString output_string;

for (;

{

switch (lex())

{

case ENDFILE:

{ dt_printeof:

return fatal("Ende der Datei erreicht. Zeile nicht korrekt abgeschlossen.");

}

break;

case '+':

{

switch (lex())

{

case ENDFILE: goto dt_printeof; break;

case IDENTIFIER: goto dt_printid ; break;

case '\"': goto dt_printgf ; break;

default:

{

return fatal("Ausdruck erwartet. Zeile nicht korrekt abgeschlossen.");

}

break;

}

}

break;

case IDENTIFIER:

{

dt_printid:

if (can_exec && !if_stmt)

{

AnsiString str;

str = "procedure_local_";

str += strlwr(token_buffer.c_str());

if (!(var_ptr = get_variable(str.c_str())))

return fatal("LOCAL Variable nicht definiert/bekannt.");

if (var_ptr->type == VARTYPE_VALUE ) { output_string += FloatToStr(var_ptr->var_value) ; } else

if (var_ptr->type == VARTYPE_STRING) { output_string += var_ptr->var_string; }

}

}

break;

case '\"':

{

dt_printgf:

char *puffer = new char[2048*2];

int pos = 0;

int c;

while ((c = fgetc(input_file)) != '"')

{

if (c == EOF) return fatal("Ende der Datei erreicht.");

if (c == '\n') return fatal("Textstring wurde nicht richtig abgeschlossen.");

else {

if (pos > (2048*2)-1)

return fatal("Stringpuffer ist voll.");

puffer[pos++] = c;

} puffer[pos] = '\0';

}

output_string += puffer;

}

break;

case ';':

goto dt_printend;

break;

default:

{

return fatal("Zeile muss mit einen Semikolon ( enden.");

}

break;

}

}

dt_printend:

if (can_exec && !if_stmt)

output_form->Memo1->Lines->Add(output_string);

}

break;

case DT_ENDIF:

{

AnsiString str;

str = "endif: ";

str += if_rec;

ShowMessage(str);

if (!if_rec) return fatal("ENDIF ohne IF-Bedingung nicht erlaubt.");

if_rec--;

if (rec) {

rec = 0;

if (!if_rec)

if_stmt = 0;

ShowMessage("endifENDIF");

return RET_OK;

}

if (!if_rec)

if_stmt = 0;

if (can_exec)

return RET_OK;

}

break;

case DT_IF:

{

if_rec++;

switch (get_token())

{

case DT_USERDEF:

{

saved_token = strlwr(token_buffer.c_str());

if (can_exec && !if_stmt)

{

AnsiString str;

str = "procedure_local_";

str += saved_token;

if (!(var_ptr = get_variable(str.c_str())))

return fatal("IF-Variable ist nicht definiert/bekannt.");

// ------------------------

// IF <variable> = EXPR ...

// ------------------------

if (var_ptr->type == VARTYPE_VALUE)

{

double wert1 = var_ptr->var_value;

int code = lex();

if (code == EQUALSIGN)

{

double wert2 = handle_expr(EP_NORMAL);

if (ptr__error) {

ptr__error = 0;

return RET_FAIL;

} ptr__error = 0;

if (wert1 == wert2)

{

ShowMessage("wert ist gleich");

can_exec = 1;

if_stmt = 0;

if (handle_procedure() == RET_FAIL)

return RET_FAIL;

}

else {

can_exec = 1;

if_stmt = 1;

if (handle_procedure() == RET_FAIL)

return RET_FAIL;

}

if (handle_procedure() == RET_FAIL)

return RET_FAIL;

}

else if (code == '>')

{

double wert2 = handle_expr(EP_NORMAL);

if (ptr__error) {

ptr__error = 0;

return RET_FAIL;

} ptr__error = 0;

if (wert1 > wert2)

{

ShowMessage("wert ist grӇer");

can_exec = 1;

if (handle_procedure() == RET_FAIL)

return RET_FAIL;

ShowMessage("reci RETURN-IF");

}

else {

can_exec = 0;

if (handle_procedure() == RET_FAIL)

return RET_FAIL;

}

}

else if (code == '<')

{

double wert2 = handle_expr(EP_NORMAL);

if (ptr__error) {

ptr__error = 0;

return RET_FAIL;

} ptr__error = 0;

if (wert1 < wert2)

{

ShowMessage("wert ist kleiner");

can_exec = 1;

}

else {

can_exec = 0;

}

}

}

// --------------------------

// IF <variable> = STRING ...

// --------------------------

else if (var_ptr->type == VARTYPE_STRING)

{

AnsiString str1;

str1 = var_ptr->var_string;

int code = lex();

if (code == EQUALSIGN)

{

}

}

else

return fatal("Typ der Variablen kann nicht bestimmt werden.");

}

// ------------------

else {

int c;

int code = lex();

if (code != EQUALSIGN) return fatal("Gleichheitszeichen (=) hier erwartet.");

c = skip_white_space();

if (c >= '0' && c <= '9')

{

ungetc(c,input_file);

double wert = handle_expr(EP_NORMAL);

if (ptr__error) {

ptr__error = 0;

return RET_FAIL;

} ptr__error = 0;

if (can_exec)

{

ShowMessage("DDD");

ShowMessage(saved_token);

ShowMessage(wert);

rec = 1;

goto next_token;

}

}

else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')

{

ungetc(c,input_file);

get_token();

}

}

}

break;

default:

{

return fatal("reservierte SchlÂsselw”rter dÂrfen hier nicht verwendet werden.");

}

break;

}

}

break;

...

}

[paule22]

ich bin schon am verzweifeln ...