Index: branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs
===================================================================
--- branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs	(revision 14818)
+++ branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs	(revision 14823)
@@ -60,11 +60,11 @@
 
     private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
-      if(node.SubtreeCount > 1) {
+      if (node.SubtreeCount > 1) {
         var token = GetToken(node.Symbol);
-        if(token == "+" || token == "-" || token == "OR" || token == "XOR") {
+        if (token == "+" || token == "-" || token == "OR" || token == "XOR") {
           strBuilder.Append("(");
           FormatRecursively(node.Subtrees.First(), strBuilder);
 
-          foreach(var subtree in node.Subtrees.Skip(1)) {
+          foreach (var subtree in node.Subtrees.Skip(1)) {
             strBuilder.Append(" ").Append(token).Append(" ");
             FormatRecursively(subtree, strBuilder);
@@ -72,9 +72,9 @@
           strBuilder.Append(")");
 
-        } else if(token == "*" || token == "/" || token == "AND") {
+        } else if (token == "*" || token == "/" || token == "AND") {
           strBuilder.Append("(");
           FormatRecursively(node.Subtrees.First(), strBuilder);
 
-          foreach(var subtree in node.Subtrees.Skip(1)) {
+          foreach (var subtree in node.Subtrees.Skip(1)) {
             strBuilder.Append(" ").Append(token).Append(" ");
             FormatRecursively(subtree, strBuilder);
@@ -85,5 +85,5 @@
           strBuilder.Append(token).Append("(");
           FormatRecursively(node.Subtrees.First(), strBuilder);
-          foreach(var subtree in node.Subtrees.Skip(1)) {
+          foreach (var subtree in node.Subtrees.Skip(1)) {
             strBuilder.Append(", ");
             FormatRecursively(subtree, strBuilder);
@@ -91,14 +91,14 @@
           strBuilder.Append(")");
         }
-      } else if(node.SubtreeCount == 1) {
+      } else if (node.SubtreeCount == 1) {
         var token = GetToken(node.Symbol);
-        if(token == "-" || token == "NOT") {
+        if (token == "-" || token == "NOT") {
           strBuilder.Append("(").Append(token).Append("(");
           FormatRecursively(node.GetSubtree(0), strBuilder);
           strBuilder.Append("))");
-        } else if(token == "/") {
+        } else if (token == "/") {
           strBuilder.Append("1/");
           FormatRecursively(node.GetSubtree(0), strBuilder);
-        } else if(token == "+" || token == "*") {
+        } else if (token == "+" || token == "*") {
           FormatRecursively(node.GetSubtree(0), strBuilder);
         } else {
@@ -110,7 +110,7 @@
       } else {
         // no subtrees
-        if(node.Symbol is LaggedVariable) {
+        if (node.Symbol is LaggedVariable) {
           var varNode = node as LaggedVariableTreeNode;
-          if(!varNode.Weight.IsAlmost(1.0)) {
+          if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
             strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Weight);
@@ -118,5 +118,5 @@
           }
           strBuilder.Append("LAG(");
-          if(varNode.VariableName.Contains("'")) {
+          if (varNode.VariableName.Contains("'")) {
             strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
           } else {
@@ -126,22 +126,22 @@
             .AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Lag)
             .Append(")");
-        } else if(node.Symbol is Variable) {
+        } else if (node.Symbol is Variable) {
           var varNode = node as VariableTreeNode;
-          if(!varNode.Weight.IsAlmost(1.0)) {
+          if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
             strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Weight);
             strBuilder.Append("*");
           }
-          if(varNode.VariableName.Contains("'")) {
+          if (varNode.VariableName.Contains("'")) {
             strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
           } else {
             strBuilder.AppendFormat("'{0}'", varNode.VariableName);
           }
-          if(!varNode.Weight.IsAlmost(1.0)) {
+          if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append(")");
           }
-        } else if(node.Symbol is FactorVariable) {
+        } else if (node.Symbol is FactorVariable) {
           var factorNode = node as FactorVariableTreeNode;
-          if(factorNode.VariableName.Contains("'")) {
+          if (factorNode.VariableName.Contains("'")) {
             strBuilder.AppendFormat("\"{0}\"", factorNode.VariableName);
           } else {
@@ -150,23 +150,30 @@
           strBuilder.AppendFormat("[{0}]",
             string.Join(", ", factorNode.Weights.Select(w => w.ToString(CultureInfo.InvariantCulture))));
-        } else if(node.Symbol is BinaryFactorVariable) {
+        } else if (node.Symbol is BinaryFactorVariable) {
           var factorNode = node as BinaryFactorVariableTreeNode;
-          if(!factorNode.Weight.IsAlmost(1.0)) {
+          if (!factorNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
             strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", factorNode.Weight);
             strBuilder.Append("*");
           }
-          if(factorNode.VariableName.Contains("'")) {
-            strBuilder.AppendFormat("\"{0}={1}\"", factorNode.VariableName, factorNode.VariableValue);
+          if (factorNode.VariableName.Contains("'")) {
+            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableName);
           } else {
-            strBuilder.AppendFormat("'{0}={1}'", factorNode.VariableName, factorNode.VariableValue);
+            strBuilder.AppendFormat("'{0}'", factorNode.VariableName);
           }
-          if(!factorNode.Weight.IsAlmost(1.0)) {
+          strBuilder.Append(" = ");
+          if (factorNode.VariableValue.Contains("'")) {
+            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableValue);
+          } else {
+            strBuilder.AppendFormat("'{0}'", factorNode.VariableValue);
+          }
+
+          if (!factorNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append(")");
           }
 
-        } else if(node.Symbol is Constant) {
+        } else if (node.Symbol is Constant) {
           var constNode = node as ConstantTreeNode;
-          if(constNode.Value >= 0.0)
+          if (constNode.Value >= 0.0)
             strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", constNode.Value);
           else
@@ -178,5 +185,5 @@
     private string GetToken(ISymbol symbol) {
       var tok = InfixExpressionParser.knownSymbols.GetBySecond(symbol).SingleOrDefault();
-      if(tok == null)
+      if (tok == null)
         throw new ArgumentException(string.Format("Unknown symbol {0} found.", symbol.Name));
       return tok;
Index: branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs
===================================================================
--- branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs	(revision 14818)
+++ branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs	(revision 14823)
@@ -132,5 +132,5 @@
 
 
-      foreach(var kvp in dict) {
+      foreach (var kvp in dict) {
         knownSymbols.Add(kvp.Key, kvp.Value);
       }
@@ -151,16 +151,16 @@
     private IEnumerable<Token> GetAllTokens(string str) {
       int pos = 0;
-      while(true) {
-        while(pos < str.Length && Char.IsWhiteSpace(str[pos])) pos++;
-        if(pos >= str.Length) {
+      while (true) {
+        while (pos < str.Length && Char.IsWhiteSpace(str[pos])) pos++;
+        if (pos >= str.Length) {
           yield return new Token { TokenType = TokenType.End, strVal = "" };
           yield break;
         }
-        if(char.IsDigit(str[pos])) {
+        if (char.IsDigit(str[pos])) {
           // read number (=> read until white space or operator or comma)
           var sb = new StringBuilder();
           sb.Append(str[pos]);
           pos++;
-          while(pos < str.Length && !char.IsWhiteSpace(str[pos])
+          while (pos < str.Length && !char.IsWhiteSpace(str[pos])
             && (str[pos] != '+' || str[pos - 1] == 'e' || str[pos - 1] == 'E')     // continue reading exponents
             && (str[pos] != '-' || str[pos - 1] == 'e' || str[pos - 1] == 'E')
@@ -174,13 +174,13 @@
           }
           double dblVal;
-          if(double.TryParse(sb.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out dblVal))
+          if (double.TryParse(sb.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out dblVal))
             yield return new Token { TokenType = TokenType.Number, strVal = sb.ToString(), doubleVal = dblVal };
           else yield return new Token { TokenType = TokenType.NA, strVal = sb.ToString() };
-        } else if(char.IsLetter(str[pos]) || str[pos] == '_') {
+        } else if (char.IsLetter(str[pos]) || str[pos] == '_') {
           // read ident
           var sb = new StringBuilder();
           sb.Append(str[pos]);
           pos++;
-          while(pos < str.Length &&
+          while (pos < str.Length &&
             (char.IsLetter(str[pos]) || str[pos] == '_' || char.IsDigit(str[pos]))) {
             sb.Append(str[pos]);
@@ -188,13 +188,13 @@
           }
           yield return new Token { TokenType = TokenType.Identifier, strVal = sb.ToString() };
-        } else if(str[pos] == '"') {
+        } else if (str[pos] == '"') {
           // read to next " 
           pos++;
           var sb = new StringBuilder();
-          while(pos < str.Length && str[pos] != '"') {
+          while (pos < str.Length && str[pos] != '"') {
             sb.Append(str[pos]);
             pos++;
           }
-          if(pos < str.Length && str[pos] == '"') {
+          if (pos < str.Length && str[pos] == '"') {
             pos++; // skip "
             yield return new Token { TokenType = TokenType.Identifier, strVal = sb.ToString() };
@@ -202,45 +202,45 @@
             yield return new Token { TokenType = TokenType.NA };
 
-        } else if(str[pos] == '\'') {
+        } else if (str[pos] == '\'') {
           // read to next '
           pos++;
           var sb = new StringBuilder();
-          while(pos < str.Length && str[pos] != '\'') {
+          while (pos < str.Length && str[pos] != '\'') {
             sb.Append(str[pos]);
             pos++;
           }
-          if(pos < str.Length && str[pos] == '\'') {
+          if (pos < str.Length && str[pos] == '\'') {
             pos++; // skip '
             yield return new Token { TokenType = TokenType.Identifier, strVal = sb.ToString() };
           } else
             yield return new Token { TokenType = TokenType.NA };
-        } else if(str[pos] == '+') {
+        } else if (str[pos] == '+') {
           pos++;
           yield return new Token { TokenType = TokenType.Operator, strVal = "+" };
-        } else if(str[pos] == '-') {
+        } else if (str[pos] == '-') {
           pos++;
           yield return new Token { TokenType = TokenType.Operator, strVal = "-" };
-        } else if(str[pos] == '/') {
+        } else if (str[pos] == '/') {
           pos++;
           yield return new Token { TokenType = TokenType.Operator, strVal = "/" };
-        } else if(str[pos] == '*') {
+        } else if (str[pos] == '*') {
           pos++;
           yield return new Token { TokenType = TokenType.Operator, strVal = "*" };
-        } else if(str[pos] == '(') {
+        } else if (str[pos] == '(') {
           pos++;
           yield return new Token { TokenType = TokenType.LeftPar, strVal = "(" };
-        } else if(str[pos] == ')') {
+        } else if (str[pos] == ')') {
           pos++;
           yield return new Token { TokenType = TokenType.RightPar, strVal = ")" };
-        } else if(str[pos] == '[') {
+        } else if (str[pos] == '[') {
           pos++;
           yield return new Token { TokenType = TokenType.LeftBracket, strVal = "[" };
-        } else if(str[pos] == ']') {
+        } else if (str[pos] == ']') {
           pos++;
           yield return new Token { TokenType = TokenType.RightBracket, strVal = "]" };
-        } else if(str[pos] == '=') {
+        } else if (str[pos] == '=') {
           pos++;
           yield return new Token { TokenType = TokenType.Eq, strVal = "=" };
-        } else if(str[pos] == ',') {
+        } else if (str[pos] == ',') {
           pos++;
           yield return new Token { TokenType = TokenType.Comma, strVal = "," };
@@ -255,5 +255,5 @@
 
       var endTok = tokens.Dequeue();
-      if(endTok.TokenType != TokenType.End)
+      if (endTok.TokenType != TokenType.End)
         throw new ArgumentException(string.Format("Expected end of expression (got {0})", endTok.strVal));
 
@@ -267,16 +267,16 @@
       var negTerms = new List<ISymbolicExpressionTreeNode>();
       bool negateFirstTerm = false;
-      if(next.TokenType == TokenType.Operator && (next.strVal == "+" || next.strVal == "-")) {
+      if (next.TokenType == TokenType.Operator && (next.strVal == "+" || next.strVal == "-")) {
         tokens.Dequeue();
-        if(next.strVal == "-")
+        if (next.strVal == "-")
           negateFirstTerm = true;
       }
       var t = ParseTerm(tokens);
-      if(negateFirstTerm) negTerms.Add(t);
+      if (negateFirstTerm) negTerms.Add(t);
       else posTerms.Add(t);
 
       next = tokens.Peek();
-      while(next.strVal == "+" || next.strVal == "-") {
-        switch(next.strVal) {
+      while (next.strVal == "+" || next.strVal == "-") {
+        switch (next.strVal) {
           case "+": {
               tokens.Dequeue();
@@ -296,7 +296,7 @@
 
       var sum = GetSymbol("+").CreateTreeNode();
-      foreach(var posTerm in posTerms) sum.AddSubtree(posTerm);
-      if(negTerms.Any()) {
-        if(negTerms.Count == 1) {
+      foreach (var posTerm in posTerms) sum.AddSubtree(posTerm);
+      if (negTerms.Any()) {
+        if (negTerms.Count == 1) {
           var sub = GetSymbol("-").CreateTreeNode();
           sub.AddSubtree(negTerms.Single());
@@ -304,5 +304,5 @@
         } else {
           var sumNeg = GetSymbol("+").CreateTreeNode();
-          foreach(var negTerm in negTerms) sumNeg.AddSubtree(negTerm);
+          foreach (var negTerm in negTerms) sumNeg.AddSubtree(negTerm);
 
           var constNode = (ConstantTreeNode)constant.CreateTreeNode();
@@ -315,5 +315,5 @@
         }
       }
-      if(sum.SubtreeCount == 1) return sum.Subtrees.First();
+      if (sum.SubtreeCount == 1) return sum.Subtrees.First();
       else return sum;
     }
@@ -321,5 +321,5 @@
     private ISymbol GetSymbol(string tok) {
       var symb = knownSymbols.GetByFirst(tok).FirstOrDefault();
-      if(symb == null) throw new ArgumentException(string.Format("Unknown token {0} found.", tok));
+      if (symb == null) throw new ArgumentException(string.Format("Unknown token {0} found.", tok));
       return symb;
     }
@@ -332,6 +332,6 @@
 
       var next = tokens.Peek();
-      while(next.strVal == "*" || next.strVal == "/") {
-        switch(next.strVal) {
+      while (next.strVal == "*" || next.strVal == "/") {
+        switch (next.strVal) {
           case "*": {
               tokens.Dequeue();
@@ -352,8 +352,8 @@
         next = tokens.Peek();
       }
-      if(factors.Count == 1) return factors.First();
+      if (factors.Count == 1) return factors.First();
       else {
         var prod = GetSymbol("*").CreateTreeNode();
-        foreach(var f in factors) prod.AddSubtree(f);
+        foreach (var f in factors) prod.AddSubtree(f);
         return prod;
       }
@@ -372,14 +372,14 @@
     private ISymbolicExpressionTreeNode ParseFact(Queue<Token> tokens) {
       var next = tokens.Peek();
-      if(next.TokenType == TokenType.LeftPar) {
+      if (next.TokenType == TokenType.LeftPar) {
         tokens.Dequeue();
         var expr = ParseExpr(tokens);
         var rPar = tokens.Dequeue();
-        if(rPar.TokenType != TokenType.RightPar)
+        if (rPar.TokenType != TokenType.RightPar)
           throw new ArgumentException("expected )");
         return expr;
-      } else if(next.TokenType == TokenType.Identifier) {
+      } else if (next.TokenType == TokenType.Identifier) {
         var idTok = tokens.Dequeue();
-        if(tokens.Peek().TokenType == TokenType.LeftPar) {
+        if (tokens.Peek().TokenType == TokenType.LeftPar) {
           // function identifier or LAG
           var funcId = idTok.strVal.ToUpperInvariant();
@@ -387,22 +387,22 @@
           var funcNode = GetSymbol(funcId).CreateTreeNode();
           var lPar = tokens.Dequeue();
-          if(lPar.TokenType != TokenType.LeftPar)
+          if (lPar.TokenType != TokenType.LeftPar)
             throw new ArgumentException("expected (");
 
           // handle 'lag' specifically
-          if(funcNode.Symbol is LaggedVariable) {
+          if (funcNode.Symbol is LaggedVariable) {
             var varId = tokens.Dequeue();
-            if(varId.TokenType != TokenType.Identifier) throw new ArgumentException("Identifier expected. Format for lagged variables: \"lag(x, -1)\"");
+            if (varId.TokenType != TokenType.Identifier) throw new ArgumentException("Identifier expected. Format for lagged variables: \"lag(x, -1)\"");
             var comma = tokens.Dequeue();
-            if(comma.TokenType != TokenType.Comma) throw new ArgumentException("',' expected, Format for lagged variables: \"lag(x, -1)\"");
+            if (comma.TokenType != TokenType.Comma) throw new ArgumentException("',' expected, Format for lagged variables: \"lag(x, -1)\"");
             double sign = 1.0;
-            if(tokens.Peek().strVal == "+" || tokens.Peek().strVal == "-") {
+            if (tokens.Peek().strVal == "+" || tokens.Peek().strVal == "-") {
               // read sign
               var signTok = tokens.Dequeue();
-              if(signTok.strVal == "-") sign = -1.0;
+              if (signTok.strVal == "-") sign = -1.0;
             }
             var lagToken = tokens.Dequeue();
-            if(lagToken.TokenType != TokenType.Number) throw new ArgumentException("Number expected, Format for lagged variables: \"lag(x, -1)\"");
-            if(!lagToken.doubleVal.IsAlmost(Math.Round(lagToken.doubleVal)))
+            if (lagToken.TokenType != TokenType.Number) throw new ArgumentException("Number expected, Format for lagged variables: \"lag(x, -1)\"");
+            if (!lagToken.doubleVal.IsAlmost(Math.Round(lagToken.doubleVal)))
               throw new ArgumentException("Time lags must be integer values");
             var laggedVarNode = funcNode as LaggedVariableTreeNode;
@@ -414,13 +414,13 @@
             var args = ParseArgList(tokens);
             // check number of arguments
-            if(funcNode.Symbol.MinimumArity > args.Length || funcNode.Symbol.MaximumArity < args.Length) {
+            if (funcNode.Symbol.MinimumArity > args.Length || funcNode.Symbol.MaximumArity < args.Length) {
               throw new ArgumentException(string.Format("Symbol {0} requires between {1} and  {2} arguments.", funcId,
                 funcNode.Symbol.MinimumArity, funcNode.Symbol.MaximumArity));
             }
-            foreach(var arg in args) funcNode.AddSubtree(arg);
+            foreach (var arg in args) funcNode.AddSubtree(arg);
           }
 
           var rPar = tokens.Dequeue();
-          if(rPar.TokenType != TokenType.RightPar)
+          if (rPar.TokenType != TokenType.RightPar)
             throw new ArgumentException("expected )");
 
@@ -428,9 +428,9 @@
         } else {
           // variable
-          if(tokens.Peek().TokenType == TokenType.Eq) {
+          if (tokens.Peek().TokenType == TokenType.Eq) {
             // binary factor
             tokens.Dequeue(); // skip Eq
             var valTok = tokens.Dequeue();
-            if(valTok.TokenType != TokenType.Identifier) throw new ArgumentException("expected identifier");
+            if (valTok.TokenType != TokenType.Identifier) throw new ArgumentException("expected identifier");
             var binFactorNode = (BinaryFactorVariableTreeNode)binaryFactorVar.CreateTreeNode();
             binFactorNode.Weight = 1.0;
@@ -438,5 +438,5 @@
             binFactorNode.VariableValue = valTok.strVal;
             return binFactorNode;
-          } else if(tokens.Peek().TokenType == TokenType.LeftBracket) {
+          } else if (tokens.Peek().TokenType == TokenType.LeftBracket) {
             // factor variable
             var factorVariableNode = (FactorVariableTreeNode)factorVar.CreateTreeNode();
@@ -447,28 +447,28 @@
             // at least one weight is necessary
             var sign = 1.0;
-            if(tokens.Peek().TokenType == TokenType.Operator) {
+            if (tokens.Peek().TokenType == TokenType.Operator) {
               var opToken = tokens.Dequeue();
-              if(opToken.strVal == "+") sign = 1.0;
-              else if(opToken.strVal == "-") sign = -1.0;
+              if (opToken.strVal == "+") sign = 1.0;
+              else if (opToken.strVal == "-") sign = -1.0;
               else throw new ArgumentException();
             }
-            if(tokens.Peek().TokenType != TokenType.Number) throw new ArgumentException("number expected");
+            if (tokens.Peek().TokenType != TokenType.Number) throw new ArgumentException("number expected");
             var weightTok = tokens.Dequeue();
             weights.Add(sign * weightTok.doubleVal);
-            while(tokens.Peek().TokenType == TokenType.Comma) {
+            while (tokens.Peek().TokenType == TokenType.Comma) {
               // skip comma
               tokens.Dequeue();
-              if(tokens.Peek().TokenType == TokenType.Operator) {
+              if (tokens.Peek().TokenType == TokenType.Operator) {
                 var opToken = tokens.Dequeue();
-                if(opToken.strVal == "+") sign = 1.0;
-                else if(opToken.strVal == "-") sign = -1.0;
+                if (opToken.strVal == "+") sign = 1.0;
+                else if (opToken.strVal == "-") sign = -1.0;
                 else throw new ArgumentException();
               }
               weightTok = tokens.Dequeue();
-              if(weightTok.TokenType != TokenType.Number) throw new ArgumentException("number expected");
+              if (weightTok.TokenType != TokenType.Number) throw new ArgumentException("number expected");
               weights.Add(sign * weightTok.doubleVal);
             }
             var rightBracketToken = tokens.Dequeue();
-            if(rightBracketToken.TokenType != TokenType.RightBracket) throw new ArgumentException("closing bracket ] expected");
+            if (rightBracketToken.TokenType != TokenType.RightBracket) throw new ArgumentException("closing bracket ] expected");
             factorVariableNode.Weights = weights.ToArray();
             return factorVariableNode;
@@ -481,5 +481,5 @@
           }
         }
-      } else if(next.TokenType == TokenType.Number) {
+      } else if (next.TokenType == TokenType.Number) {
         var numTok = tokens.Dequeue();
         var constNode = (ConstantTreeNode)constant.CreateTreeNode();
@@ -495,7 +495,7 @@
       var exprList = new List<ISymbolicExpressionTreeNode>();
       exprList.Add(ParseExpr(tokens));
-      while(tokens.Peek().TokenType != TokenType.RightPar) {
+      while (tokens.Peek().TokenType != TokenType.RightPar) {
         var comma = tokens.Dequeue();
-        if(comma.TokenType != TokenType.Comma) throw new ArgumentException("expected ',' ");
+        if (comma.TokenType != TokenType.Comma) throw new ArgumentException("expected ',' ");
         exprList.Add(ParseExpr(tokens));
       }
