Einheiten parsen

[Mikkey]

Ich würde es für sinnvoller und wesentlich einfacher halten, wenn Du Dir einen fertigen Parser nimmst, und diesen entsprechend nach Deinen Bedürfnissen anpasst.

- Leerzeichen werden ignoriert
- Du hast Zahlen, musst das Dezimalkomma ensprechend behandeln.
- wenn auf eine Ziffer ein Buchstabe folgt, handelt es sich um eine Einheit, implizit wird eine Multiplikation eingefügt; die Einheit wird gegen den Satz von Einheiten geprüft
- wenn auf einen Buchstaben eine Klammer auf folgt, ist es ein Funktionsaufruf, das Token wird dann gegen den Satz der verfügbaren Funktionen geprüft
- Klammerung sollte der Standardparser bereits beherrschen.

Es ist generell keine gute Idee, in den Parser gleich die Interpretation des Ausdrucks einzubauen. Stattdessen kannst Du den gepars-ten Ausdruck auswerten und weißt dabei vorher, dass Du keinen Syntaxfehler hast.

[Bjoerk]

Hallo Mikkey, das ist ein fertiger Parser. Und implizit kann man da m.E. nicht einfach mal eine Multiplikation einführen? Mir gehts hier nur um das Handling der Rekursion (Wie kommt man die Einheit ran?)

[Dejan Vu]

Eine Konstante ist nicht nur einfach eine Zahl, sondern entweder ein Faktor oder ein physikalischer Wert.

Code:

NumericConstant ::= Factor | PhysicalValue
Factor ::= AnyNumber
PhysicalValue ::= AnyNumber [Unit]

PS: Wenn du die Frage nach Rekursivität stellst, dann hast Du nicht wirklich einen Parser. Oder Du hast einen, weißt aber nicht, wie man ihn verwendet. Oder Du hast einen, weißt, wie man ihn verwendet, hast aber einfach die falsche Frage gestellt.

[Bjoerk]

Hi Bud,
ja, die Rekursion hatte ich gestern nicht wirklich (mehr) kapiert gehabt. Aber heute ist ein neuer Tag. So wie ich's vorhatte ging's aus mehreren Gründen nicht. Man kann entweder mit Äpfeln (double) mit oder Birnen (TEinheiten) rechnen. Also dann doch einen Extradurchlauf. Man braucht eine neue Solve.

Delphi-Quellcode:

function TJMUnitParser.Solve(S: string): TParserUnitStyle;
begin
  try
    if LastPos('+', S) > 0 then
      Result := GetPlus(Solve(Left(S, '+', true)), Solve(Right(S, '+', true)))
    else
      if LastPos('-', S) > 0 then
        Result := GetMinus(Solve(Left(S, '-', true)), Solve(Right(S, '-', true)))
      else
        if LastPos('*', S) > 0 then
          Result := GetMult(Solve(Left(S, '*', true)), Solve(Right(S, '*', true)))
        else
          if LastPos('/', S) > 0 then
            Result := GetDiv(Solve(Left(S, '/', true)), Solve(Right(S, '/', true)))
          else
            if LastPos(':', S) > 0 then // div;
              Result := GetIntDiv(Solve(Left(S, ':', true)), Solve(Right(S, ':', true)))
            else
              if LastPos('\', S) > 0 then // mod;
                Result := GetIntMod(Solve(Left(S, '\', true)), Solve(Right(S, '\', true)))
              else
                if FirstPos('^', S) > 0 then
                  Result := GetPower(Solve(Left(S, '^', false)), Solve(Right(S, '^', false)))
                else
                  if Parenthesis(S) then // ( .. )
                    Result := Solve(S)
                  else
                    Result := FUnits.SignToStyle(S);
  except
    Result := pusNone;
  end;
end;

Vom Ablauf her isses hier so: Im obigen Beispiel 5,0 kN/m2 * 0,70 m / cos(30) wird beim Aufbereiten für's Einheitenparsen zunächst [Einheit_1][Einheit_ kN/m2] * [Einheit_m] / [Einheit_1]. Um den Term Term mathematisch so zu parsen wie den Term ohne Einheiten braucht muß man nur [Einheit_1][Einheit_ X] zu [Einheit_ X] ersetzen (bzw. [Einheit_ X][Einheit_1] zu [Einheit_ X]).

Hab den Code mal angehängt. Falls du Böcke hat, eine Variante mit einem Stack wär' nicht schlecht.

LG
Thomas

[Dejan Vu]

Hmm. Du solltest deinen Parser so schreiben, wie man eine Grammatik schreibt.
D.h.
1. Du baust dir einen Tokenizer/Lexer, der dir aus deinem String die entsprechenden Token (Operator, Klammer, Zahl, Einheit) extrahiert.

2. Dann schreibst Du den Parser. Leider hab ich gerade keinen da, weil ich unterwegs bin und mein Privatlaptop mit einem fertigen Parser zuhause ist. Im Prinzip geht es so:

Delphi-Quellcode:

// Term ::= Zahl Operator Zahl | '(' Term ')'
function IsTerm (var term : TParserNode) : Boolean;
Var
  leftNumber, operator, rightNumber : TToken;

begin
  result := false
  if IsOpenBracket then begin
    if IsTerm (term) then
      if IsClosingBracket then 
        exit(true);
    SyntaxError('Term expected');
  end
  else
    if IsZahl(leftNumber) then
      if IsOperator(operator) then
        If IsZahl(rightNumber) then begin
          term := TTermNode.Create (leftNumber, operator, rightNumber)
          result := True;
        end;
// falls result=false ist, müsstest du hier noch aufräumen, oder mit interfaces arbeiten
end;

'IsZahl' liefert true, wenn das nächste Token eine Zahl ist. außerdem wird in 'leftNumber' dann die Zahl geliefert.
Das gleiche gilt für 'IsOperator'. 'IsTerm' macht im Prinzip genau das Gleiche: Wenn es die Tokensequenz einen Term ergibt, liefert die Funktion 'True' und den Term.

Wichtig ist, das man beim Erkennen eines Tokens zum nächsten geht. Manchmal muss man sich das aktuelle Token, sondern das darauf folgende Token anschauen, um zu entscheiden, was zu tun ist (look ahead).

[Bjoerk]

Ja, das weiß ich doch selbst? Dieser Parser arbeitet aber halt anders. Ansonsten ja zum Beispiel so, so einen hab ich auch mal gemacht.

Delphi-Quellcode:

procedure TParser.ParseFunctions(var S: string);
var
  Index: integer;
begin
  Index := OperatorPos(S, 'A');
  while Index > 0 do
  begin
    MathWork(S, Index);
    Index := OperatorPos(S, 'A');
  end;
end;

procedure TParser.ParseOperator(var S: string; const AOperator: Char);
var
  Index: integer;
begin
  Index := OperatorPos(S, AOperator);
  while Index > 0 do
  begin
    MathWork(S, Index);
    Index := OperatorPos(S, AOperator);
  end;
end;

procedure TParser.Parse(var S: string);
begin
  // Diese Reihenfolge
  ParseFunctions(S); // Funktionen, Von Rechts nach Links;
  ParseOperator(S, '^'); // Power, Von Rechts nach Links;
  ParseOperator(S, '*'); // Punktrechnung, Von Links nach Rechts;
  ParseOperator(S, '+'); // Strichrechnung Von Links nach Rechts;
end;

function TParser.Solve(T: string; Sender: boolean): string; // Aufruf mit Sender = false;
var
  A, B: Integer;
  S: string;
  AFloat: double;
begin
  while HaveBrackets(T, A, B) do
  begin
    S := StrMid(T, A + 1, B - 1);
    Solve(S, true);
    Parse(S);
    T := StrLeft(T, A - 1) + S + StrRight(T, B + 1);
  end;
  if not Sender then
  begin
    Parse(T);
    if TryStrToFloat(GetNumber(T), AFloat) then
      Result := GetNumber(T)
    else
      Result := '0'; // Syntaxerror
  end;
end;

[Bjoerk]

Was ich aber nicht hinkrieg ist daraus einen Stack zu machen?

Delphi-Quellcode:

function TJMUnitParser.Solve(S: string): TParserUnitStyle;
begin
  try
    if LastPos('+', S) > 0 then
      Result := FUnits.GetAdd(Solve(Left(S, '+', true)), Solve(Right(S, '+', true)))
    else
      if LastPos('/', S) > 0 then
        Result := FUnits.GetMult(Solve(Left(S, '/', true)), Solve(Right(S, '/', true)))
      else
        if LastPos('*', S) > 0 then
          Result := FUnits.GetDiv(Solve(Left(S, '*', true)), Solve(Right(S, '*', true)))
        else
          if FirstPos('^', S) > 0 then
            Result := FUnits.GetPower(Solve(Left(S, '^', false)), Solve(Right(S, '^', false)))
          else
            if Parenthesis(S) then
              Result := Solve(S)
            else
              Result := FUnits.SignToStyle(S);
  except
    Result := pusNone;
  end;
end;

In meinem jugendlichen Leichtsinn hab ich mal dahin überlegt? Geht das so in der Richtung?

Delphi-Quellcode:

function TJMUnitParser.Solve(const Term: string): TParserUnitStyle;
var
  Stack: TParserStack;
begin
  Result := pusNone;
  Stack := TParserStack.Create;
  try
    Stack.Push(Term);
    while not Stack.Empty do
    begin
      S := Stack.Pop.S;
      if LastPos('+', S) > 0 then
      begin
        Result :=
        Stack.Push(S);
      end
      else
        if LastPos('/', S) > 0 then
        begin
          Result :=
          Stack.Push(S);
        end
        else
          if LastPos('*', S) > 0 then
          begin
            Result :=
            Stack.Push(S);
          end
          else
            if Parenthesis(S) then
            begin
              Result :=
              Stack.Push(S);
            end
            else
              Result := FUnits.SignToStyle(S);
    end;
  finally
    Stack.Free;
  end;
end;