Changeset 15017 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs

Timestamp:

06/01/17 09:28:34 (7 years ago)

Author:

pkimmesw

Message:

#2665 Fixed Benchmark Problem Definition, Converted LoopExpressions to stateless expressions, Added several unit test to ensure funcionality, Fixed UI bugs

File:

• branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs (modified) (8 diffs)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Parser {
+  using System;
   using System.Collections.Generic;
   using System.Globalization;
   using System.Linq;
+  using System.Text.RegularExpressions;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Constants;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
 
   public static class PushParser {
-    private const string openBrace = "(";
-
-    private const string closeBrace = ")";
-
     private const char delimiter = ' ';
 
@@ -17 +17 @@
 
     public static Expression Parse(string source, int startIndex = 0) {
-      var symbols = source.Split(delimiter);
+      bool error;
+      var symbols = GetSymbols(source, out error); // source.Split(delimiter);
 
       int endIndex;
-      return Parse(symbols, 0, out endIndex);
+      return Parse(symbols, startIndex, out endIndex);
     }
 
@@ -29 +30 @@
     }
 
-    private static Expression Parse(string[] symbols, int startIndex, out int endIndex) {
+    private static IReadOnlyList<string> GetSymbols(string source, out bool error) {
+      var chars = source.ToCharArray();
+      var symbols = new List<string>();
+
+      for (var i = 0; i < chars.Length; i++) {
+        var cur = chars[i];
+        int endIndex;
+        int length;
+        string str;
+
+        switch (cur) {
+          case delimiter: break;
+          case PushEnvironment.StringSymbol:
+            endIndex = source.IndexOf(PushEnvironment.StringSymbol, i + 1);
+            if (endIndex < i) {
+              error = true;
+              return symbols;
+            }
+
+            length = endIndex - i + 1;
+            str = source.Substring(i, length);
+            symbols.Add(str);
+            i += length; // skip following space
+
+            break;
+
+          case PushEnvironment.CharSymbol:
+            endIndex = source.IndexOf(PushEnvironment.CharSymbol, i + 1);
+            if (endIndex < i) {
+              error = true;
+              return symbols;
+            }
+
+            length = endIndex - i + 1;
+            str = source.Substring(i, length);
+            str = EscapeLikeALiteral(str);
+            symbols.Add(str);
+            i += length; // skip following space
+
+            break;
+
+          case PushEnvironment.VectorStartSymbol:
+            endIndex = source.IndexOf(PushEnvironment.VectorEndSymbol, i + 1);
+            if (endIndex < i) {
+              error = true;
+              return symbols;
+            }
+
+            length = endIndex - i + 1;
+            str = source.Substring(i, length);
+            symbols.Add(str);
+            i += length; // skip following space
+            break;
+
+          default:
+            endIndex = source.IndexOf(' ', i + 1);
+
+            length = endIndex < i
+              ? chars.Length - i
+              : endIndex - i;
+
+            str = source.Substring(i, length);
+            symbols.Add(str);
+            i += length; // skip following space
+
+            break;
+        }
+      }
+
+      error = true;
+      return symbols;
+    }
+
+    private static Expression Parse(IReadOnlyList<string> symbols, int startIndex, out int endIndex) {
       var expressions = new List<Expression>();
 
-      for (var i = startIndex; i < symbols.Length; i++) {
+      for (var i = startIndex; i < symbols.Count; i++) {
         var symbol = symbols[i].TrimEnd(symbolTrim);
 
@@ -38 +112 @@
 
         switch (symbol) {
-          case openBrace:
+          case PushEnvironment.ProgramStartSymbolStr:
             var subExpression = Parse(symbols, i + 1, out endIndex);
             expressions.Insert(0, subExpression);
             i = endIndex;
             continue;
-          case closeBrace:
+          case PushEnvironment.ProgramEndSymbolStr:
             endIndex = i;
             return new PushProgram(expressions);
@@ -66 +140 @@
       }
 
-      endIndex = symbols.Length - 1;
+      endIndex = symbols.Count - 1;
 
       switch (expressions.Count) {
@@ -79 +153 @@
 
     private static bool TryParseLiteral(string word, out Expression expression) {
-      if (word.StartsWith("'") && word.EndsWith("'") && word.Length == 3) {
-        expression = new CharPushExpression(word[1]);
-        return true;
-      }
-
-      if (word.StartsWith("\"") && word.EndsWith("\"")) {
-        expression = new StringPushExpression(word);
-        return true;
-      }
-
-      // "[]" has no values and can therefer not parsed correctly as vector of a specific type
-      if (word.StartsWith("[") && word.EndsWith("]") && word.Length > 3) {
+      if (word.StartsWith(PushEnvironment.CharSymbolStr) &&
+          word.EndsWith(PushEnvironment.CharSymbolStr) &&
+          word.Length == 3) {
+          expression = new CharPushExpression(word[1]);
+          return true;
+      }
+
+      if (word.StartsWith(PushEnvironment.StringSymbolStr) &&
+          word.EndsWith(PushEnvironment.StringSymbolStr)) {
+        var stringValue = word.Length == 0 ? string.Empty : word.Substring(1, word.Length - 2);
+        expression = new StringPushExpression(stringValue);
+        return true;
+      }
+
+      // "[]" has no values and can therefor not parsed correctly as vector of a specific type
+      if (word.StartsWith(PushEnvironment.VectorStartSymbolStr) &&
+          word.EndsWith(PushEnvironment.VectorEndSymbolStr) &&
+          word.Length > 2) {
+
         var vectorEntries = word
           .Substring(1, word.Length - 2)
-          .Split(',')
-          .Select(x => {
-            Expression e;
-            var success = TryParseLiteral(x.Trim(), out e);
-
-            return new { success, e, type = e.GetType() };
-          })
+          .Split(PushEnvironment.VectorSeparatorSymbol)
           .ToArray();
 
@@ -107 +182 @@
         }
 
-        var vectorEntryType = vectorEntries.First().type;
-        if (vectorEntries.Any(x => !x.success || x.type != vectorEntryType)) {
+        Expression e;
+        var first = vectorEntries.First();
+        if (!TryParseLiteral(first, out e)) {
           expression = null;
           return false;
         }
 
-        var result = vectorEntries
-          .Select(x => x.e)
-          .ToArray();
-
-        // TODO
-        //switch(vectorEntryType.GetHashCode())
-        //{
-        //  case typeof(IntegerPushExpression).GetHashCode(): return new IntegerVectorPushExpression(result)
-        //}
-
-        //expression = new StringPushExpression(word);
-        //return true;
+        if (e.GetType() == typeof(IntegerPushExpression)) {
+          var integerValues = vectorEntries.Select(long.Parse).ToArray();
+          expression = new IntegerVectorPushExpression(integerValues);
+        } else if (e.GetType() == typeof(FloatPushExpression)) {
+          var doubleValues = vectorEntries.Select(x => double.Parse(x, NumberStyles.Float, cultureInfo)).ToArray();
+          expression = new FloatVectorPushExpression(doubleValues);
+        } else if (e.GetType() == typeof(StringPushExpression)) {
+          var stringValues = vectorEntries.Select(str => str.Substring(1, str.Length - 2)).ToArray();
+          expression = new StringVectorPushExpression(stringValues);
+        } else if (e.GetType() == typeof(BooleanPushExpression)) {
+          var booleanValues = vectorEntries.Select(bool.Parse).ToArray();
+          expression = new BooleanVectorPushExpression(booleanValues);
+        } else {
+          expression = null;
+          return false;
+        }
+
+        return true;
       }
 
@@ -148 +230 @@
       return false;
     }
+
+    private static string EscapeLikeALiteral(string src) {
+      return Regex.Replace(src, @"\\(?<simple>['""\\0abfnrtv])", m => {
+        var s = m.Groups["simple"].Value;
+        switch (s) {
+          case "'": return "'";
+          case "\"": return "\"";
+          case "0": return "\0";
+          case "a": return "\a";
+          case "b": return "\b";
+          case "f": return "\f";
+          case "n": return "\n";
+          case "r": return "\r";
+          case "t": return "\t";
+          case "v": return "\v";
+          default:
+            throw new InvalidOperationException();
+        }
+      });
+    }
   }
 }