// Wer hier den alten Parser-Code sucht, den muss ich enttäuschen.
// Er wurde von mir ins Nirwana geschickt. Ich benötigte nämlich einen
// flexibleren, mit dem man beispielsweise den String
//
'SIN(X/PI)^2,1 + 3/4 - (WURZ(2 + Z) + LG(1 - Y)) + 3Y + 2E3 - FAK(5)'
//
umsetzen kann, der also Potenzieren, Logarithmieren, Radizieren,
// Multiplizieren, Dividieren, Addieren und Subtrahieren ausführt, sowie
// geschachtelte Klammern erkennt, Fakultäten errechnet, grundlegende
// Winkelfunktionen beherrscht und auch Variablen (X, Y, Z) verarbeitet,
// damit man gleiche Aufgabenstellung mit verschiedenen Ausgangswerten
// miteinander vergleichen kann. Ergebnisse mit Nachkommastellen sollten
// mindestens eine Genauigkeit von 10 Stellen hinter dem Komma haben.
//
// Also habe ich einen neuen Parser geschrieben.
//

// Getestet mit D4 unter XP
//
// in der Hoffnung, keinen Fehler übersehen zu haben,
// aber mit keinerlei Garantie.

// Überarbeitet 24.02.2010


// Variablen
// ----------------
//
KommaStellen:
// Legt die maximale Anzahl der Stellen nach dem Komma fest. Sollte das
// Ergebnis mehr Stellen haben, wird gerundet.

// ---------------- 
// Separator:
// Bestimmt, ob im Ergebnis Tausendertrennzeichen eingefügt werden.
// ---------------- 
// NachNullenEntfernen:
// Abschließende Nullen werden gelöscht: 
10,123000 => 10,123    12,0 => 12
// ----------------
// Tausenderpunkte:
// Bestimmt, ob in der Eingabe Tausendertrenner erlaubt sind. Da man leicht
// Komma und Punkt verwechseln kann, ist dies nicht zu empfehlen.
// ----------------
// Wissenschaftlich:
// Bei sehr großen oder sehr kleinen Zahlen, wird die wissenschaftliche
// Notation im Ergebnis erzwungen. Beispielsweise bei 500 Fakultät würde
// das Ergebnis 1135 Stellen haben. Da ist die Anzeige
// 1,22013682599111E1134 schon überschaubarer.
// ----------------

 
// Syntax  
// ----------------
// Zahlen:
// [man kann Zahlen in verschiedenen Schreibweisen eingeben]
// ganze Zahlen                 :   45678906
// [Wenn Tausenderpunkte = True]:   45.678.906
// Dezimalzahlen                : 1234567,89 [bzw. 1.234.567,89]
// hexadezimale Darstellung     : $123ABC oder #123ABC
// wissenschaftliche Notation   : 123E4 oder 123E+4 bzw. 123E-4
// [innerhalb von Zahlen sind keine Leerzeichen erlaubt.
// 12 34 oder 123 E-4 oder 2, 5 führen zu: "Ergebnis nicht ermittelbar"]
// ----------------
// Potenzieren:
// [Als Rechenzeichen kann man ^ oder ** verwenden]
// Zwei hoch Drei => 2^3
// Vier hoch Fünf => 4**5
// ----------------
// Radizieren:
// [als Rechenzeichen verwendet man WURZ]
// vierte Wurzel aus 16  => 4 WURZ 16
// Quadrat-Wurzel aus 25 => 2 WURZ 25 oder nur WURZ 25
// dritte Wurzel aus 27  => 3 WURZ 27
// drei mal Wurzel 27    => 3(WURZ 27)  siehe Klammern
// [für komplexe Wurzelexponenten muss man geschweifte
// Klammern verwenden. Siehe unten "Sonderklammern"]
// vierte Wurzel aus 16  => {3+1}WURZ 16 [ = 2 ]
// [normale Klammern ergäben:
// (3+1) Wurzel 16 = (3+1)(Wurzel 16) = 4 * 4 = 16
// Für komplexe Radikanden muss man jedoch
// normale Klammern verwenden]
// vierte Wurzel aus 16  => 4 WURZ (10+6)
// [negative Radikanden führen immer zu: "Ergebnis nicht ermittelbar".
// Brüche als Wurzelexponenten müssen nicht unbedingt in geschweiften
// Klammern stehen, es wird aber empfohlen. Vergleiche:
//       - WURZ 2 = {- 2} WURZ 2 = 0,707106781186548
//         1/2 WURZ 2 = {1/2} WURZ 2 = 4
//       - 1/2 WURZ 2 = {-1/2} WURZ 2 = 0,25
// Aber: - {-1/2} WURZ 2 = --1/2 WURZ 2 = 1/2 WURZ 2 = 4
//      (siehe Sonderklammern)
//       - (1/2 WURZ 2) = -4
//       - (-1/2 WURZ 2) = -0,25
//       - (1/2) WURZ 2 = -1/2 * WURZ 2 = -0,70710678118655
//       (siehe Klammern )
//     1 - 1/2 WURZ 2 = 1 - (1/2 WURZ 2) = -3
//     (2+3){1+2} WURZ 2 = 5{3} WURZ 2 = 53 WURZ 2 = 1,01316414302491
//     (2+3)*{1+2} WURZ 2 = (2+3)*({1+2} WURZ 2) = 6,29960524947435
// ----------------
// Multiplizieren:
// [das Rechenzeichen ist * ]
// Sechs mal Drei => 6 * 3
// ----------------
// Dividieren:
// [das Rechenzeichen ist / oder : ]
// Sechs geteilt durch drei  => 6 / 3
// Acht geteilt durch sieben => 8 : 7
// ----------------
// Winkelfunktionen:
// [Eingaben in Grad und nicht in Bogenmaß]
// Sinus(1)    => SIN(1) oder SIN 1
// Cosinus(2)  => COS(2) oder COS 2
// Tangens(3)  => TAN(3) oder TAN 3
// Cotanges(4) => COTAN(4) oder COTAN 4
// ----------------
// Addieren:
// [das Rechenzeichen ist + ]
// Fünf plus drei Komma drei => 5 + 3,3
// ----------------
// Subtrahieren:
// [das Rechenzeichen ist - ]
// Vier minus drei => 4 - 3
// ----------------
// Kehrwert:
// [KEHR]
// Kehrwert von 10 => KEHR(10) oder KEHR 10
// ----------------
// Logarithmus:
// [Dekadischer Logarithmus  LG ]
// Logarithmus von 200 => LG(200) oder LG 200
// [Natürlicher Logarithmus  LN ]
// Natürlicher Logarithmus von 200 => LN(200) oder LN 200
// ----------------
// Pi:
// [einfach  PI ]
// wird mit 19 Stellen hinter dem Komma eingesetzt => 3.1415926535897932385
// ----------------
// Eulersche Zahl:
// [einfach  EU ]
// wird mit 19 Stellen hinter dem Komma eingesetzt => 2.7182818284590452354
// ----------------
// Fakultät [Faktorielle]:
// [FAK]
// Fünf Fakultät => FAK(5) oder FAK 5 [ = 1*2*3*4*5 = 120 ]
// ----------------
// Variablen:
// [Es sind drei Variablen erlaubt: X, Y, Z,
// denen man vor Gebrauch einen (Gleitkomma)Wert zuweisen muss]
// Vier X => 4X oder 4*X
// ----------------
// Klammern:
// [Klammer auf ( und Klammer zu  ) ]
// Drei mal (X plus Y)                     => 3(X+Y) oder 3*(X+Y)
// (Y minus Drei Komma Acht) mal minus 1   => (Y-3,8)(-1) oder (Y-3,8)*-1
// Zweite Wurzel aus dritter Wurzel aus 27 => WURZ(3 WURZ 27)
// [zwischen Klammern, Zahlen und Funktionen wird ein Multiplikationszeichen
// erzeugt, sofern kein anderes Rechenzeichen vorhanden ist:
// (1+2)(3+4) = (1+2)*(3+4) = 3 * 7 = 21
// 100(5*6) = 100*(5*6) = 100 * 30 = 3000
// (2/4)LG200 = (2/4)*LG(200) = 0,5 * 2,30102999566398 = 1,15051499783199 ]
// Sonderklammern:
// [geschweifte Klammer auf { und zu  }
// Bei Sonderklammern wird kein Multiplikationszeichen erzeugt, sondern
// der Klammerbegriff ausgerechnet und dann einfach nur eingesetzt.
// Das wird zum Errechnen komplexer Wurzelexponenten genutzt.
// Siehe weiter oben. Aber Vorsicht beim Einsatz!! Sie sollten diese Klammern
// nur beim Radizieren nutzen.]
// {1+2}45 = {3}45 = 345
// (5-1){5-2}(5-3) = 4{3}2 = 432
// {1/2} LG 10 = {0,5}1 = 0,51
// {1/4} SIN 10 = {0,25}( 0,1736) = 0, 0,1736 = Ergebnis nicht ermittelbar
// ----------------
// Min / Max:
// [Kleinste bzw. größte Zahl. Trenner entweder ; oder \ ]
// Kleinster Wert => MIN(2; 10; 5; 4; -3,6) [ = -3,6 ]
// Größter Wert   => MAX(2\ 10\ 5\ 4\ -3,6) [ = 10 ]
// ----------------
// Beachten Sie auch bitte die Komma-Schreibweise:
// 2,(1+5) = 2,0 * (1+5) = 12   aber  2,{1+5} = 2,6
// (1+5),1 = (1+5) * 0,1 = 0,6  aber  {1+5},1 = 6,1
// 4,-3 = 4,0 -3 = 1
----------------
// Hinweis:
// Nicht nur falsche Syntax, sondern auch zu große oder zu kleine
// Anfangswerte bzw. Endergebnisse sowie Division durch Null führen
// zur Ausschrift:
// "Ergebnis nicht ermittelbar 
// ----------------

 

uses math;
const 
  zhln = ['0'..'9']; 
  vars = ['x'..'z']; 
  hexa = ['a'..'f']; 
  cons = ['p', 'u']; 
  begn = ['$', '(']; 
  rez1 = ['+', '-']; 
  rez2 = ['*', '/', '^']; 
  funs = ['!', 'k', 'l', 'ü', 's', 'i', 't', 'o', 'n', 'm']; 
  ff = 'Ergebnis nicht ermittelbar'; 
 
function klammerzahl(f: string): boolean; 
const 
  zuk = [')', '}']; 
var 
  auf, zu: integer; 
  p: pchar; 
begin 
  result := false; 
  auf := 0; 
  zu := auf; 
  p := @f[1]; 
  while p^ <> #0 do begin 
    if p^ in ['(', '{'] then begin 
      inc(p); 
      if p^ in zuk then exit; 
      inc(auf); 
      continue; 
    end else 
      if p^ in zuk then inc(zu); 
    inc(p); 
  end; 
  result := auf = zu; 
end; 
 
function ishex(var f: string): boolean; 
var 
  i, v, h, d: integer; 
  s: string; 
begin 
  v := pos('$', f); 
  result := false; 
  if v = length(f) then exit; 
  repeat 
    if v = 0 then begin 
      result := true; 
      exit; 
    end; 
    h := 0; 
    for i := v + 1 to length(f) do begin 
      if not (f[i] in zhln + hexa) then begin 
        if (f[i] = Decimalseparator) then exit; 
        h := i; 
        break; 
      end; 
    end; 
    if h = 0 then h := length(f) + 1; 
    s := copy(f, v, h - v); 
    try 
      d := strtoint(s); 
      s := inttostr(d); 
    except 
      exit; 
    end; 
    delete(f, v, h - v); 
    insert(s, f, v); 
    v := pos('$', f); 
  until false; 
end; 
 
function Fakul(value: cardinal): extended; 
begin 
  result := 1; 
  repeat 
    result := result * value; 
    dec(value); 
  until value <= 1; 
end; 
 
function klaeren(f: string): string; 
begin 
  result := stringreplace(f, '+-', '-', [rfreplaceall]); 
  result := stringreplace(result, '-+', '-', [rfreplaceall]); 
  result := stringreplace(result, '++', '+', [rfreplaceall]); 
  result := stringreplace(result, '--', '+', [rfreplaceall]); 
end; 
 
function such(var s: string; rz: char; p: integer): boolean; 
var 
  pl, pr, i, lg, np: integer; 
  erg: extended; 
  l, r: string; 
begin 
  result := false; 
  l := ''; 
  pl := 0; 
  try 
    for i := p - 1 downto 0 do begin 
      if (s[i] = '-') and (copy(s, i + 1, 1) <> '{') 
        and ((i = 1) or (copy(s, i - 1, 1) = ';')) 
        then begin 
        pl := i; 
        break; 
      end; 
      if not (s[i] in zhln + [Decimalseparator, 'e', '°', '/']) 
        then begin 
        pl := i + 1; 
        break; 
      end; 
    end; 
    l := copy(s, pl, p - pl); 
    lg := length(l); 
    repeat 
      np := pos('/', l); 
      if np = 0 then break; 
      if not such(l, '/', np) then exit; 
    until false; 
    r := ''; 
    pr := maxint; 
    for i := p + 1 to length(s) do begin 
      if (s[i] = '-') and (s[i - 1] <> rz) then begin 
        pr := i - 1; 
        break; 
      end; 
      if (s[i] = '+') then begin 
        if s[i - 1] <> rz then begin 
          pr := i - 1; 
          break; 
        end else continue; 
      end; 
      if not (s[i] in zhln + [Decimalseparator, 'e', '°', '-']) 
        then begin 
        pr := i - 1; 
        break; 
      end; 
    end; 
    r := copy(s, p + 1, pr - p); 
    lg := lg + length(r) + 1; 
    r := stringreplace(r, '°', 'e-', [rfreplaceall]); 
    l := stringreplace(l, '°', 'e-', [rfreplaceall]); 
    case rz of 
      '^': erg := power(strtofloat(l), strtofloat(r)); 
      'w': erg := power(strtofloat(r), 1 / strtofloat(l)); 
      '/': erg := strtofloat(l) / strtofloat(r); 
      '*': erg := strtofloat(l) * strtofloat(r); 
      '+': erg := strtofloat(l) + strtofloat(r); 
      '-': erg := strtofloat(l) - strtofloat(r); 
    else exit; 
    end; 
  except 
    exit; 
  end; 
  delete(s, pl, lg); 
  insert(floattostr(erg), s, pl); 
  s := klaeren(s); 
  result := true; 
end; 
 
function kommatest(s: string): boolean; 
begin 
  result := (pos('|,', s) = 0) and 
    (pos(',|', s) = 0); 
end; 
 
function rechne(var f: string; v, h: integer): boolean; 
const 
  zweier: array[0..5] of char = ('^', 'w', '/', '*', '+', '-'); 
var 
  s: string; 
  p, x, z, i, k: integer; 
  c: char; 
  function minmax(ma: boolean; var s: string): boolean; 
  var w: integer; 
    a, b: extended; 
  begin 
    result := false; 
    try 
      w := pos(';', s); 
      if w <> 0 then begin 
        a := strtofloat(copy(s, 1, w - 1)); 
        s := copy(s, w + 1, maxint); 
        w := pos(';', s); 
        if w = 0 then b := strtofloat(s) else begin 
          result := minmax(ma, s); 
          if not result then exit; 
          b := strtofloat(s); 
        end; 
        if ma then begin 
          if (b < a) then s := floattostr(a) 
          else s := floattostr(b); 
        end else begin 
          if (b > a) then s := floattostr(a) 
          else s := floattostr(b); 
        end; 
      end; 
      result := true; 
    except; 
    end; 
  end; 
begin 
  s := copy(f, v + 1, h - 2); 
  result := true; 
  c := f[v - 1]; 
  if c in ['w', 'ü', 'l', 's', 'i', 'o', 't', 'k', 'n', 'm'] 
    then begin 
    result := kommatest(s); 
    if not result then exit; 
  end; 
  s := stringreplace(s, '|', '', [rfreplaceall]); 
  z := 1; 
  for x := 0 to high(zweier) do 
    repeat 
      s := stringreplace(lowercase(s), 'e-', '°', [rfreplaceall]); 
      s := klaeren(s); 
      i := 1 + ord(copy(s, 1, 1) = '-'); 
      p := pos(zweier[x], copy(s, i, maxint)); 
      if p = 0 then break; 
      inc(p, ord(i > 1)); 
      if s[p - 1] = ';' then break; 
      result := result and such(s, zweier[x], p); 
      if not result then exit; 
    until false; 
  try 
    result := false; 
    case c of 
      'n': if not minmax(false, s) then exit; 
      'm': if not minmax(true, s) then exit; 
      '!': begin 
          k := strtoint(s); 
          if k < 0 then exit; 
          s := floattostr(fakul(k)); 
        end; 
      'l': s := floattostr(log10(strtofloat(s))); 
      'ü': s := floattostr(logN(2.7182818284590452354, strtofloat(s))); 
      's': s := floattostr(sin(DegToRad(strtofloat(s)))); 
      'i': s := floattostr(cos(DegToRad(strtofloat(s)))); 
      't': s := floattostr(tan(DegToRad(strtofloat(s)))); 
      'o': s := floattostr(cotan(DegToRad(strtofloat(s)))); 
      'k': s := floattostr((1 / strtofloat(s))); 
    else z := 0; 
    end; 
    delete(f, v - z, h + z); 
    insert(s, f, v - z); 
    f := klaeren(f); 
    result := true; 
  except 
  end; 
end; 
 
function RundX(zahl: extended; kommastellen: byte): string; 
begin 
  result := formatfloat('0.' + stringofchar('0', kommastellen), zahl); 
end; 
 
function ExtendedToString(zahl: extended; Separator: boolean; 
  kommastellen: byte): string; 
var 
  pe, pk, i, k, m, z: integer; 
  ex: boolean; 
  hlp: string; 
begin 
  result := rundx(zahl, kommastellen); 
  pe := pos('e', lowercase(result)); 
  if pe > 0 then begin 
    ex := copy(result, pe + 1, 1) = '-'; 
    i := strtoint(copy(result, pe + 1 + ord(ex), maxint)); 
    result := copy(result, 1, pe - 1); 
    pk := pos(Decimalseparator, result); 
    if pk = 0 then z := 0 
    else begin 
      delete(result, pk, 1); 
      z := 2; 
    end; 
    if ex then begin 
      result := stringofchar('0', i - pk + z) + result; 
      k := pk - i; 
      if k < 2 then k := 2; 
      insert(Decimalseparator, result, k); 
    end else 
      result := result + stringofchar('0', i + ord(pk > 0) * (pk - pe + 1)); 
  end else begin 
    hlp := FloatToStrF(zahl, ffFixed, 18, kommastellen); 
    if length(hlp) > length(result) then result := hlp; 
  end; 
  if not Separator then exit; 
  pk := pos(',', result); 
  if pk = 0 then i := length(result) - 2 
  else i := pk - 3; 
  m := ord(copy(result, 1, 1) = '-') + 1; 
  while i > m do begin 
    insert(Thousandseparator, result, i); 
    dec(i, 3); 
  end; 
end; 
 
function test(f: string): boolean; 
var 
  p: pchar; 
begin 
  f := lowercase(f); 
  result := false; 
  p := @f[1]; 
  while p^ <> #0 do begin 
    if not (p^ in zhln + hexa + cons + begn + rez1 + rez2 + funs + [')', 'w', 
      Decimalseparator, '°', ';', '|']) 
      then exit; 
    inc(p); 
  end; 
  result := true; 
end; 
 
function Parse(f: string; KommaStellen: byte; 
  Separator, NachNullenEntfernen, Tausenderpunkte, wissenschaftlich: boolean; 
  x, y, z: extended): string; 
var 
  i, a: integer; 
begin 
  if kommastellen > 15 then kommastellen := 15; 
  result := ff; 
  f := ansilowercase(Trim(f)); 
  if not Tausenderpunkte and (pos(ThousandSeparator, f) > 0) then exit; 
  try 
    i := pos(#32, f); 
    if i > 0 then 
      while i <= length(f) do begin 
        if f[i] = #32 then begin 
          if (f[i - 1] in zhln + hexa + [Decimalseparator]) 
            and (f[i + 1] in zhln + hexa + [Decimalseparator]) 
            then exit; 
          delete(f, i, 1); 
        end else inc(i); 
      end; 
    if f = '' then exit; 
    // 'a'..'f' ist hex !!! 
    f := stringreplace(f, 'fak', '!', [rfreplaceall]); 
    f := stringreplace(f, 'cotan', 'o', [rfreplaceall]); 
    f := stringreplace(f, '**', '^', [rfreplaceall]); 
    f := stringreplace(f, '#', '$', [rfreplaceall]); 
    f := stringreplace(f, ':', '/', [rfreplaceall]); 
    f := stringreplace(f, ThousandSeparator, '', [rfreplaceall]); 
    f := stringreplace(f, 'pi', 'p', [rfreplaceall]); 
    f := stringreplace(f, 'wurz', 'w', [rfreplaceall]); 
    f := stringreplace(f, 'kehr', 'k', [rfreplaceall]); 
    f := stringreplace(f, 'eu', 'u', [rfreplaceall]); 
    f := stringreplace(f, 'ln', 'ü', [rfreplaceall]); 
    f := stringreplace(f, 'lg', 'l', [rfreplaceall]); 
    f := stringreplace(f, 'sin', 's', [rfreplaceall]); 
    f := stringreplace(f, 'cos', 'i', [rfreplaceall]); 
    f := stringreplace(f, 'tan', 't', [rfreplaceall]); 
    f := stringreplace(f, 'min', 'n', [rfreplaceall]); 
    f := stringreplace(f, 'max', 'm', [rfreplaceall]); 
    f := stringreplace(f, '\', ';', [rfreplaceall]); 
    f := klaeren(f); 
    if f[1] = '+' then f := copy(f, 2, maxint); 
    if f[1] in rez2 then exit; 
    if (f[1] = Decimalseparator) or (f[1] = 'e') 
      then f := '0' + f; 
    i := 2; 
    while i <= length(f) do begin 
      if (f[i] = Decimalseparator) then begin 
        if f[i + 1] = Decimalseparator then exit; 
        if not (f[i - 1] in zhln + ['}'] + vars) 
          then begin 
          insert('0', f, i); 
          inc(i); 
        end; 
        if not (f[i + 1] in zhln + ['{'] + vars) 
          then begin 
          inc(i); 
          insert('0', f, i); 
        end; 
      end; 
      inc(i); 
    end; 
    i := 2; 
    while i < length(f) do begin 
      if (f[i] = '$') and (f[i - 1] in vars + cons + hexa + zhln) 
        then begin 
        insert('*', f, i); 
        inc(i); 
      end; 
      inc(i); 
    end; 
    if not ishex(f) then exit; 
    i := 1; 
    a := 0; 
    while i <= length(f) do begin 
      if f[i] in funs + ['^', 'w'] then begin 
        inc(i); 
        if f[i] <> '(' then begin 
          insert('(', f, i); 
          inc(a); 
        end; 
      end else 
        if (a > 0) and 
          not (f[i + 1] in zhln + cons + vars + [Decimalseparator]) 
          and not (f[i] in rez1) 
          or (i = length(f)) 
          then begin 
          insert(stringofchar(')', a), f, i + 1); 
          inc(i, a); 
          a := 0; 
        end; 
      inc(i); 
    end; 
    if not Klammerzahl(f) then exit; 
    if f[1] = 'w' then f := '2' + f; 
    i := 2; 
    while i <= length(f) do begin 
      if (f[i] = 'w') and (not (f[i - 1] in zhln + [DecimalSeparator, '}'])) 
        then begin 
        insert('2', f, i); 
        inc(i); 
      end; 
      inc(i); 
    end; 
    i := 1; 
    while i < length(f) do begin 
      if (f[i] in zhln + hexa + vars + cons) 
        and (f[i + 1] in vars + cons + begn + funs) 
        or (f[i] in [')'] + cons + vars) and (f[i + 1] 
        in zhln + begn + vars + cons + funs) 
        then begin 
        insert('*', f, i + 1); 
        inc(i); 
      end; 
      inc(i); 
    end; 
    f := stringreplace(f, '{', '(', [rfreplaceall]); 
    f := stringreplace(f, '}', ')', [rfreplaceall]); 
    f := stringreplace(f, 'u', '2' + DecimalSeparator + 
      '7182818284590452354', [rfreplaceall]); 
    f := stringreplace(f, 'p', '3' + DecimalSeparator + 
      '1415926535897932385', [rfreplaceall]); 
    f := stringreplace(f, 'x', '|' + floattostr(x) + '|', [rfreplaceall]); 
    f := stringreplace(f, 'y', '|' + floattostr(y) + '|', [rfreplaceall]); 
    f := stringreplace(f, 'z', '|' + floattostr(z) + '|', [rfreplaceall]); 
    f := stringreplace(f, 'e+', 'e', [rfreplaceall]); 
    f := stringreplace(f, 'e-', '°', [rfreplaceall]); 
    f := '(' + f + ')'; 
    if (pos('(^', f) > 0) or (pos('(*', f) > 0) 
      or (pos('(/', f) > 0) or not test(f) then exit; 
    repeat 
      i := lastdelimiter('(', f); 
      if i = 0 then break; 
      f := stringreplace(f, '(+', '(', [rfreplaceall]); 
      a := pos(')', copy(f, i, maxint)); 
      if not rechne(f, i, a) then exit; 
      f := stringreplace(f, '°', 'e-', [rfreplaceall]); 
    until false; 
    if wissenschaftlich then 
      result := FloatToStrF(strtofloat(f), ffFixed, 18, kommastellen) else 
      result := ExtendedToString(strtofloat(f), Separator, kommastellen); 
  except 
    exit; 
  end; 
  if NachNullenEntfernen then 
    while (pos(Decimalseparator, result) > 0) 
      and ((ansilastchar(result) = '0') 
      or (ansilastchar(result) = Decimalseparator)) 
      do delete(result, length(result), 1); 
end;
 
// Beispielaufruf 
 
procedure TForm10.Button1Click(Sender: TObject); 
var s: string; 
  x, y, z: double; 
  kommastellen: byte; 
  Separator, NachnullenEntfernen, TausenderPunkte, Wissenschaftlich: boolean; 
begin 
  x := 2; 
  y := -3; 
  z := 4.5; 
  Separator := true; 
  TausenderPunkte := false; 
  Wissenschaftlich := true; 
  NachnullenEntfernen := false; 
  s := 'SIN(X/PI)^2,1+3/4-(WURZ(2+Z)+LG(1-Y))+7,7*$FF-3Y+2E3-FAK(5)'; 
  kommastellen := 2; 
  s := parse(s, Kommastellen, Separator, NachnullenEntfernen, 
    TausenderPunkte, Wissenschaftlich, x, y, z); 
  showmessage(s); 
end;


Zugriffe seit 6.9.2001 auf Delphi-Ecke