Expression Crawling

[RalleYTN]

Hey Loits!
Ich bin gerade dabei einen Evaluator für FIQL zu schreiben und ich stehe derzeit ein bisschen auf dem Schlauch. Die Klammern machen mir Probleme. Ich dachte ich mache mir einen Expression Crawler. Also nehmen wir mal an wir hätten jetzt eine Pseudo-Expression:

x1;((x2,x3);(x4;(x5,x6)))

Die Variablen hier wären jetzt boolische Werte, ';' ist ein UND und ',' ein ODER.
Jetzt würde ich gerne die Sub-Expression des "tiefsten" Scope auflösen und mich dann hoch arbeiten, bis ich nur noch einen entgültigen Wert habe.
Für das Beispiel würde jetzt also die Funktion "eval(String expression)" mit folgenden Werten und in der Reihenfolge aufgerufen werden. 'E' makiert hier immer das Ergebnis einer Evaluation.

1 x5,x6
2 x4;E1
3 x2,x3
4 E2;E3
5 x1;E4

Das ganze bereitet mir ein bisschen Kopfschmerzen, weil ich keine Ahnung habe wie ich da rangehen soll.

 

[mrBrown]

Ich würde das in einen Baum überführen, jeder Wert bzw. ein Operator ist ein Knoten, Knoten haben eine Funktion die den berechneten Wert zurückgeben. Klingt eigentlich trivial, wenn ich grad nichts überseh...

 

[Flown]

Warum nimmst du für sowas nicht einen Compilergenerator, wie etwa CoCo/R, da du ja schon die EBNF davon hast?

 

[RalleYTN]

Warum nimmst du für sowas nicht einen Compilergenerator, wie etwa CoCo/R, da du ja schon die EBNF davon hast?

Ich würde das schon gerne ohne andere Tools und Libraries machen. Soll auch einen Lerneffekt haben.

Klingt eigentlich trivial, wenn ich grad nichts überseh...

Ich weiss..... Dann habe ich versucht es umzusetzen....

Das mit der Baumstruktur klingt auf jeden Fall interressant.

 

[RalleYTN]

Ok ich glaube ich habs geschafft.
Ist sicher nicht die schnellste Lösung aber es funktioniert.

    public static final boolean eval(String fiql, String value) {
      
       if(fiql.contains("(")) {
          
           char[] tokens = fiql.toCharArray();
           Stack<Integer> scope = new Stack<>();
          
           for(int index = 0; index < tokens.length; index++) {
              
               if(tokens[index] == '(') {
                  
                   scope.push(index);
                  
               } else if(tokens[index] == ')') {
                  
                   if(!scope.isEmpty()) {
                      
                       int start = scope.pop();
                       boolean result = process(fiql.substring(start + 1, index),  value);
                      
                       StringBuilder builder = new StringBuilder(fiql);
                       builder.delete(start, index + 1);
                       builder.insert(start, Boolean.toString(result));
                      
                       return eval(builder.toString(), value);
                      
                   }
               }
           }
          
       } else {
          
           return process(fiql, value);
       }
      
       return false;
   }
  
   private static final boolean process(String expression, String val) {
      
       System.out.println(expression);
       return false;
   }

Ausgabe für die Expression:

x1;((x2,x3);(x4;(x5,x6)))

x2,x3
x5,x6
x4;false
false;false
x1;false

 

[Flown]

Ein Lerneffekt kann man auch erzielen, wenn man bewehrte Tools für den richtigen Job verwendet und somit sich die Arbeit - vielleicht später einmal - erleichtert.

Aber wenn du das händisch umsetzen möchtest, dann solltest du Expression-Bäume bauen, wie mrBrown schon sagte.