Changeset 9078 for branches/RuntimeOptimizer/HeuristicLab.Persistence

Timestamp:

12/19/12 11:16:51 (12 years ago)

Author:

abeham

Message:

#1985: Updated branch from trunk

Location:

branches/RuntimeOptimizer

Files:

• . (modified) (1 prop)
• HeuristicLab.Persistence (modified) (1 prop)
• HeuristicLab.Persistence/3.3/Auxiliary/TypeLoader.cs (modified) (3 diffs)
• HeuristicLab.Persistence/3.3/Auxiliary/TypeName.cs (modified) (7 diffs)
• HeuristicLab.Persistence/3.3/Auxiliary/TypeNameParser.cs (modified) (17 diffs)

branches/RuntimeOptimizer/HeuristicLab.Persistence/3.3/Auxiliary/TypeLoader.cs

@@ -29 +29 @@
   internal class TypeLoader {
     #region Mono Compatibility
-    private static TypeName cachedRuntimeType;
-    private static TypeName cachedObjectEqualityComparerType;
+    private static TypeName cachedMonoRuntimeType;
+    private static TypeName cachedWindowsRuntimeType;
+    private static TypeName cachedMonoObjectEqualityComparerType;
+    private static TypeName cachedWindowsObjectEqualityComparerType;
+
+    private static bool MonoInstalled {
+      get { return Type.GetType("Mono.Runtime") != null; }
+    }
 
     static TypeLoader() {
       // we use Int32 here because we get all the information about Mono's mscorlib and just have to change the class name
-      cachedRuntimeType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
-      cachedRuntimeType = new TypeName(cachedRuntimeType, "MonoType");
+      cachedMonoRuntimeType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
+      cachedMonoRuntimeType = new TypeName(cachedMonoRuntimeType, "MonoType");
+
+      cachedWindowsRuntimeType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
+      cachedWindowsRuntimeType = new TypeName(cachedWindowsRuntimeType, "RuntimeType");
 
       // we need the information about the Persistence assembly, so we use TypeName here because it is contained in this assembly
-      cachedObjectEqualityComparerType = TypeNameParser.Parse(typeof(TypeName).AssemblyQualifiedName);
-      cachedObjectEqualityComparerType = new TypeName(cachedObjectEqualityComparerType, "ObjectEqualityComparer", "HeuristicLab.Persistence.Mono");
+      cachedMonoObjectEqualityComparerType = TypeNameParser.Parse(typeof(TypeName).AssemblyQualifiedName);
+      cachedMonoObjectEqualityComparerType = new TypeName(cachedMonoObjectEqualityComparerType, "ObjectEqualityComparer", "HeuristicLab.Persistence.Mono");
+
+      cachedWindowsObjectEqualityComparerType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
+      cachedWindowsObjectEqualityComparerType = new TypeName(cachedWindowsObjectEqualityComparerType, "ObjectEqualityComparer", "System.Collections.Generic");
     }
     #endregion
@@ -60 +72 @@
       catch (PersistenceException) {
         #region Mono Compatibility
-        // if that fails, try to load Mono type
-        TypeName monoTypeName = GetMonoType(typeName);
-        Logger.Info(String.Format(@"Trying to load Mono type ""{0}"" instead of type ""{1}""",
-                                  monoTypeName, typeNameString));
-        return LoadInternal(monoTypeName);
+        // if that fails, try to convert to the corresponding Mono or .NET type
+        if (MonoInstalled) {
+          typeName = GetMonoType(typeName);
+          Logger.Info(String.Format(@"Trying to load Mono type ""{0}"" instead of .NET type ""{1}""",
+                                    typeName, typeNameString));
+        } else {
+          typeName = GetDotNetType(typeName);
+          Logger.Info(String.Format(@"Trying to load .NET type ""{0}"" instead of Mono type ""{1}""",
+                                    typeName, typeNameString));
+
+        }
+        return LoadInternal(typeName);
+        #endregion
       }
-        #endregion
     }
 
@@ -134 +153 @@
       // map System.RuntimeType to System.MonoType
       if (typeName.Namespace == "System" && typeName.ClassName == "RuntimeType") {
-        return cachedRuntimeType;
+        return cachedMonoRuntimeType;
         // map System.Collections.Generic.ObjectEqualityComparer to HeuristicLab.Mono.ObjectEqualityComparer
       } else if (typeName.Namespace == "System.Collections.Generic" && typeName.ClassName == "ObjectEqualityComparer") {
-        TypeName newTypeName = new TypeName(cachedObjectEqualityComparerType);
+        TypeName newTypeName = new TypeName(cachedMonoObjectEqualityComparerType);
+        newTypeName.GenericArgs = new List<TypeName>(typeName.GenericArgs);
+        return newTypeName;
+      }
+      return typeName;
+    }
+
+    /// <summary>
+    /// Returns the corresponding type for the .NET runtime
+    /// </summary>
+    /// <returns>
+    /// The remapped typeName, or the original typeName if no mapping was found
+    /// </returns>
+    private static TypeName GetDotNetType(TypeName typeName) {
+      // map System.MonoType to System.RuntimeType
+      if (typeName.Namespace == "System" && typeName.ClassName == "MonoType") {
+        return cachedWindowsRuntimeType;
+        // maps Mono's string comparer to System.Collections.Generic.ObjectEqualityComparer<string>
+      } else if (typeName.Namespace == "System.Collections.Generic" && typeName.ClassName == "InternalStringComparer") {
+        TypeName newTypeName = new TypeName(cachedWindowsObjectEqualityComparerType);
+        var genericArgsList = new List<TypeName>();
+        genericArgsList.Add(new TypeName(typeof(String).Namespace, "String"));
+        newTypeName.GenericArgs = genericArgsList;
+        return newTypeName;
+      } else if (typeName.Namespace == "System.Collections.Generic" && typeName.ClassName == "EqualityComparer+DefaultComparer") {
+        TypeName newTypeName = new TypeName(cachedWindowsObjectEqualityComparerType);
         newTypeName.GenericArgs = new List<TypeName>(typeName.GenericArgs);
         return newTypeName;

branches/RuntimeOptimizer/HeuristicLab.Persistence/3.3/Auxiliary/TypeName.cs

@@ -51 +51 @@
 
     /// <summary>
+    /// Gets or sets the number of generic args for
+    /// each class in a series of nested classes.
+    /// </summary>
+    [Storable]
+    public List<int> GenericArgCounts { get; private set; }
+
+      /// <summary>
     /// Gets or sets the generic args.
     /// </summary>
@@ -103 +110 @@
     /// <param name="nameSpace">The namespace.</param>
     /// <param name="className">Name of the class.</param>
-    internal TypeName(string nameSpace, string className) {
+    internal TypeName(string nameSpace, string className, List<int> genericArgCounts=null) {
       Namespace = nameSpace;
       ClassName = className;
@@ -109 +116 @@
       MemoryMagic = "";
       AssemblyAttribues = new Dictionary<string, string>();
+      if (genericArgCounts != null)
+        GenericArgCounts = genericArgCounts.ToList();
     }
 
     internal TypeName(TypeName typeName, string className = null, string nameSpace = null) {
-      Namespace = typeName.Namespace;
-      ClassName = typeName.ClassName;
+      Namespace = nameSpace ?? typeName.Namespace;
+      ClassName = className ?? typeName.ClassName;
       GenericArgs = new List<TypeName>(typeName.GenericArgs);
       AssemblyAttribues = new Dictionary<string, string>(typeName.AssemblyAttribues);
@@ -119 +128 @@
       AssemblyName = typeName.AssemblyName;
       IsReference = typeName.IsReference;
-      if (nameSpace != null)
-        Namespace = nameSpace;
-      if (className != null)
-        ClassName = className;
+      if (typeName.GenericArgCounts != null)
+        GenericArgCounts = typeName.GenericArgCounts.ToList();
     }
 
@@ -148 +155 @@
     /// </returns>
     public string ToString(bool full, bool includeAssembly) {
-      StringBuilder sb = new StringBuilder();
+      var sb = new StringBuilder();
       if (!string.IsNullOrEmpty(Namespace))
         sb.Append(Namespace).Append('.');
-      sb.Append(ClassName);
+      if (GenericArgCounts != null) {
+        sb.Append(string.Join("+",
+          ClassName
+          .Split('+')
+          .Zip(GenericArgCounts, (n, c) =>
+            c > 0 ? String.Format("{0}`{1}", n, c) : n)));
+      } else {
+        sb.Append(ClassName);
+        if (IsGeneric)
+          sb.Append('`').Append(GenericArgs.Count);
+      }
       if (IsGeneric) {
-        sb.Append('`').Append(GenericArgs.Count).Append('[');
-        bool first = true;
-        foreach (TypeName t in GenericArgs) {
-          if (first)
-            first = false;
-          else
-            sb.Append(',');
-          sb.Append('[').Append(t.ToString(full)).Append(']');
-        }
+        sb.Append('[');
+        sb.Append(String.Join(",", GenericArgs.Select(a =>
+          string.Format("[{0}]", a.ToString(full)))));
         sb.Append(']');
       }
@@ -174 +185 @@
     }
 
-    public string GetTypeNameInCode(HashSet<string> omitNamespaces) {
-      StringBuilder sb = new StringBuilder();
-      if (!string.IsNullOrEmpty(Namespace) && omitNamespaces == null || !omitNamespaces.Contains(Namespace))
-        sb.Append(Namespace).Append('.');
-      sb.Append(ClassName);
-      if (IsGeneric) {
-        sb.Append("<");
-        sb.Append(
-          string.Join(", ",
-            GenericArgs
-              .Select(a => a.GetTypeNameInCode(omitNamespaces))
-              .ToArray()));
-        sb.Append(">");
+    private IEnumerable<string> GetNestedClassesInCode(HashSet<string> omitNamespaces, bool includeAllNamespaces) {
+      var i = 0;
+      foreach (var pair in ClassName.Split('+').Zip(GenericArgCounts, (n, c) => new {n, c})) {
+        if (pair.c == 0) {
+          yield return pair.n;
+        }
+        else {
+          yield return string.Format("{0}<{1}>",
+            pair.n,
+            string.Join(",",
+              GenericArgs
+                .GetRange(i, pair.c)
+                .Select(a => a.GetTypeNameInCode(omitNamespaces, includeAllNamespaces))));
+          i += pair.c;
+        }
+      }
+    }
+
+    private string GetTypeNameInCode(HashSet<string> omitNamespaces, bool includeNamespaces) {
+      var sb = new StringBuilder();
+      if (!string.IsNullOrEmpty(Namespace) &&
+            (omitNamespaces == null && includeNamespaces) ||
+             omitNamespaces != null && !omitNamespaces.Contains(Namespace))
+          sb.Append(Namespace).Append('.');
+      if (GenericArgCounts != null) {
+        sb.Append(string.Join(".", GetNestedClassesInCode(omitNamespaces, includeNamespaces)));
+      } else {
+        sb.Append(ClassName);
+        if (IsGeneric) {
+          sb.Append("<");
+          sb.Append(
+            string.Join(", ",
+                        GenericArgs
+                          .Select(a => a.GetTypeNameInCode(omitNamespaces, includeNamespaces))
+                          .ToArray()));
+          sb.Append(">");
+        }
       }
       sb.Append(MemoryMagic);
@@ -192 +227 @@
     }
 
-    public string GetTypeNameInCode(bool includeAllNamespaces) {
-      StringBuilder sb = new StringBuilder();
-      if (includeAllNamespaces)
-        sb.Append(Namespace).Append('.');
-      sb.Append(ClassName);
-      if (IsGeneric) {
-        sb.Append("<");
-        sb.Append(
-          string.Join(", ",
-            GenericArgs
-              .Select(a => a.GetTypeNameInCode(includeAllNamespaces))
-              .ToArray()));
-        sb.Append(">");
-      }
-      sb.Append(MemoryMagic);
-      return sb.ToString();
+    public string GetTypeNameInCode(HashSet<string> omitNamespaces) {
+      return GetTypeNameInCode(omitNamespaces, false);
+    }
+
+    public string GetTypeNameInCode(bool includeNamespaces) {
+      return GetTypeNameInCode(null, includeNamespaces);
     }
 

branches/RuntimeOptimizer/HeuristicLab.Persistence/3.3/Auxiliary/TypeNameParser.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -46 +47 @@
   /// 
   /// SimpleTypeSpec := (IDENTIFIER '.')*
-  ///                   (IDENTIFIER '+')*
+  ///                   (IDENTIFIER '`\d+'? '+')*
   ///                    IDENTIFIER
   ///                   ( '`\d+[' Generics ']' )?
@@ -69 +70 @@
 
       SimpleTypeSpec := (IDENTIFIER '.')*
-                        (IDENTIFIER '+')*
-                         IDENTIFIER
-                        ( '`\d+[' Generics ']' )?
+                        (IDENTIFIER '`\d+'?
+                        ( '+' IDENTIFIER '`\d+'? )*
+                        ( '[' Generics ']' )?
                         (\*|\[(\d+\.\.\d+|\d+\.\.\.|(|\*)(,(|\*))*)\])* 
                         (',\s*' IDENTIFIER (',\s*' AssemblyProperty)* )?
 
-      Generics := '[' SimpleTypeSpec ']' (',[' SimpleTypeSpec ']')
+      Generics := '[' SimpleTypeSpec ']' (',[' SimpleTypeSpec ']')*
 
       AssemblyProperty := 'Version=' Version
@@ -88 +89 @@
 
     private class Token {
-      private static Dictionary<string, string> tokens =
-        new Dictionary<string, string> {
-          {"-", "DASH"},
-          {"&", "AMPERSAND"},
-          {".", "DOT"},
-          {"+", "PLUS"},
-          {",", "COMMA"},
-          {"[", "OPEN_BRACKET"},
-          {"]", "CLOSE_BRACKET"},
-          {"*", "ASTERISK"},
-          {" ", "SPACE"},
-          {"=", "EQUALS"},
-          {"`", "BACKTICK"} };
-      private static Regex NumberRegex = new Regex("^\\d+$");
-      private static Regex IdentifierRegex = new Regex("^[_a-zA-Z][_a-zA-Z0-9]*$");
-      private static Regex TokenRegex = new Regex("[-&.+,\\[\\]* =`]|[a-f0-9]+|\\d+|[_a-zA-Z][_a-zA-Z0-9]*");
-      public string Name { get; private set; }
+      public enum Symbol { None, Dash, Ampersand, Dot, Plus, Comma, OpenBracket, CloseBracket, Asterisk, Space, Equals, Backtick }
+      private static readonly Dictionary<string, Symbol> TOKENS =
+        new Dictionary<string, Symbol> {
+          {"-", Symbol.Dash},
+          {"&", Symbol.Ampersand},
+          {".", Symbol.Dot},
+          {"+", Symbol.Plus},
+          {",", Symbol.Comma},
+          {"[", Symbol.OpenBracket},
+          {"]", Symbol.CloseBracket},
+          {"*", Symbol.Asterisk},
+          {" ", Symbol.Space},
+          {"=", Symbol.Equals},
+          {"`", Symbol.Backtick}};
+      private static readonly Regex NumberRegex = new Regex("^\\d+$");
+      private static readonly Regex IdentifierRegex = new Regex("^[_a-zA-Z][_a-zA-Z0-9]*$");
+      private static readonly Regex TokenRegex = new Regex("[-&.+,\\[\\]* =`]|[a-f0-9]+|\\d+|[_a-zA-Z][_a-zA-Z0-9]*");
+      public Symbol Name { get; private set; }
       public string Value { get; private set; }
       public bool IsIdentifier { get; private set; }
@@ -111 +113 @@
       private Token(string value, int pos) {
         Position = pos;
-        if (tokens.ContainsKey(value)) {
-          Name = tokens[value];
+        Name = Symbol.None;
+        if (TOKENS.ContainsKey(value)) {
+          Name = TOKENS[value];
         } else if (NumberRegex.IsMatch(value)) {
           Number = int.Parse(value);
@@ -128 +131 @@
       }
       public override string ToString() {
-        if (Name != null)
+        if (Name != Symbol.None)
           return "Token(" + Name + ")";
         if (Value != null)
@@ -154 +157 @@
     /// <summary>
     /// Parses the specified typename string as obtained by
-    /// <c>System.Object.GetType().FullName"</c>.
+    /// <c>System.Object.GetType().FullName</c> or 
+    /// <c>System.Object.GetType().AssemblyQualifiedName</c>.
     /// </summary>
     /// <param name="s">The typename string.</param>
@@ -181 +185 @@
     private TypeName TransformTypeSpec() {
       TypeName t = TransformSimpleTypeSpec();
-      t.IsReference = ConsumeToken("AMPERSAND");
+      t.IsReference = ConsumeToken(Token.Symbol.Ampersand);
       return t;
     }
 
     private TypeName TransformSimpleTypeSpec() {
-      List<string> nameSpace = new List<string>();
-      nameSpace.Add(ConsumeIdentifier());
-      while (ConsumeToken("DOT"))
+      var nameSpace = new List<string> { ConsumeIdentifier() };
+      while (ConsumeToken(Token.Symbol.Dot))
         nameSpace.Add(ConsumeIdentifier());
-      List<string> className = new List<string>();
+      var className = new List<string>();
       if (nameSpace.Count > 0) {
         className.Add(nameSpace[nameSpace.Count - 1]);
         nameSpace.RemoveAt(nameSpace.Count - 1);
       }
-      while (ConsumeToken("PLUS"))
+      var genericArgCounts = new List<int> {
+        ConsumeToken(Token.Symbol.Backtick) ? ConsumeNumber() : 0
+      };
+      while (ConsumeToken(Token.Symbol.Plus)) {
         className.Add(ConsumeIdentifier());
-      TypeName typeName = new TypeName(
+        genericArgCounts.Add(ConsumeToken(Token.Symbol.Backtick) ? ConsumeNumber() : 0);
+      }
+      var nGenericArgs = genericArgCounts.Sum();
+      var typeName = new TypeName(
         string.Join(".", nameSpace.ToArray()),
-        string.Join("+", className.ToArray()));
-      if (ConsumeToken("BACKTICK")) {
-        int nGenericArgs = ConsumeNumber();
-        if (ConsumeToken("OPEN_BRACKET") &&
-          CanConsumeToken("OPEN_BRACKET")) {
-          typeName.GenericArgs.AddRange(TransformGenerics());
-          ConsumeToken("CLOSE_BRACKET", true);
-        }
-      }
-      StringBuilder pointerOrArray = new StringBuilder();
+        string.Join("+", className.ToArray()),
+        nGenericArgs > genericArgCounts.Last() ? genericArgCounts : null);
+      if (nGenericArgs > 0 && ConsumeToken(Token.Symbol.OpenBracket, true)) {
+        typeName.GenericArgs.AddRange(TransformGenerics());
+        ConsumeToken(Token.Symbol.CloseBracket, true);
+      }
+      var pointerOrArray = new StringBuilder();
       while (true) {
-        if (ConsumeToken("ASTERSIK")) {
+        if (ConsumeToken(Token.Symbol.Asterisk)) {
           pointerOrArray.Append("*");
-        } else if (ConsumeToken("OPEN_BRACKET")) {
+        } else if (ConsumeToken(Token.Symbol.OpenBracket)) {
           pointerOrArray.Append('[');
           ParseDimension(pointerOrArray);
-          while (ConsumeToken("COMMA")) {
+          while (ConsumeToken(Token.Symbol.Comma)) {
             pointerOrArray.Append(",");
             ParseDimension(pointerOrArray);
           }
-          ConsumeToken("CLOSE_BRACKET", true);
+          ConsumeToken(Token.Symbol.CloseBracket, true);
           pointerOrArray.Append(']');
         } else {
@@ -227 +233 @@
       typeName.MemoryMagic = pointerOrArray.ToString();
       if (ConsumeComma()) {
-        StringBuilder sb = new StringBuilder();
+        var sb = new StringBuilder();
         sb.Append(ConsumeIdentifier());
-        while (CanConsumeToken("DOT") ||
-          CanConsumeToken("DASH") ||
+        while (CanConsumeToken(Token.Symbol.Dot) ||
+          CanConsumeToken(Token.Symbol.Dash) ||
           CanConsumeNumber() ||
           CanConsumeIdentifier()) {
-          if (ConsumeToken("DOT"))
+          if (ConsumeToken(Token.Symbol.Dot))
             sb.Append('.');
-          else if (ConsumeToken("DASH"))
+          else if (ConsumeToken(Token.Symbol.Dash))
             sb.Append('-');
           else if (CanConsumeNumber())
@@ -253 +259 @@
 
     private void ParseDimension(StringBuilder sb) {
-      if (ConsumeToken("ASTERSIK")) {
+      if (ConsumeToken(Token.Symbol.Asterisk)) {
         sb.Append("*");
       } else if (CanConsumeNumber()) {
         sb.Append(ConsumeNumber());
-        ConsumeToken("DOT", true);
-        ConsumeToken("DOT", true);
-        if (ConsumeToken("DOT")) {
+        ConsumeToken(Token.Symbol.Dot, true);
+        ConsumeToken(Token.Symbol.Dot, true);
+        if (ConsumeToken(Token.Symbol.Dot)) {
           sb.Append("...");
         } else {
@@ -268 +274 @@
 
     private IEnumerable<TypeName> TransformGenerics() {
-      ConsumeToken("OPEN_BRACKET", true);
+      ConsumeToken(Token.Symbol.OpenBracket, true);
       yield return TransformSimpleTypeSpec();
-      ConsumeToken("CLOSE_BRACKET", true);
-      while (ConsumeToken("COMMA")) {
-        ConsumeToken("OPEN_BRACKET", true);
+      ConsumeToken(Token.Symbol.CloseBracket, true);
+      while (ConsumeToken(Token.Symbol.Comma)) {
+        ConsumeToken(Token.Symbol.OpenBracket, true);
         yield return TransformSimpleTypeSpec();
-        ConsumeToken("CLOSE_BRACKET", true);
+        ConsumeToken(Token.Symbol.CloseBracket, true);
       }
     }
@@ -280 +286 @@
     private KeyValuePair<string, string> TransformAssemblyProperty() {
       if (ConsumeIdentifier("Version")) {
-        ConsumeToken("EQUALS", true);
+        ConsumeToken(Token.Symbol.Equals, true);
         return new KeyValuePair<string, string>(
           "Version",
@@ -300 +306 @@
 
     private KeyValuePair<string, string> ConsumeAssignment(string name) {
-      ConsumeToken("EQUALS", true);
+      ConsumeToken(Token.Symbol.Equals, true);
       return new KeyValuePair<string, string>(name, ConsumeToken());
     }
@@ -307 +313 @@
       StringBuilder version = new StringBuilder();
       version.Append(ConsumeNumber());
-      ConsumeToken("DOT");
+      ConsumeToken(Token.Symbol.Dot);
       version.Append('.').Append(ConsumeNumber());
-      ConsumeToken("DOT");
+      ConsumeToken(Token.Symbol.Dot);
       version.Append('.').Append(ConsumeNumber());
-      ConsumeToken("DOT");
+      ConsumeToken(Token.Symbol.Dot);
       version.Append('.').Append(ConsumeNumber());
       return version.ToString();
@@ -368 +374 @@
 
     private bool ConsumeComma() {
-      if (ConsumeToken("COMMA")) {
-        while (ConsumeToken("SPACE")) ;
+      if (ConsumeToken(Token.Symbol.Comma)) {
+        while (ConsumeToken(Token.Symbol.Space)) ;
         return true;
       } else {
@@ -376 +382 @@
     }
 
-    private bool ConsumeToken(string name) {
-      return ConsumeToken(name, false);
-    }
-
-    private bool CanConsumeToken(string name) {
-      if (tokens.Count == 0)
-        return false;
-      if (tokens.Peek().Name == name)
+    private bool ConsumeToken(Token.Symbol symbol) {
+      return ConsumeToken(symbol, false);
+    }
+
+    private bool CanConsumeToken(Token.Symbol symbol) {
+      if (tokens.Count == 0)
+        return false;
+      if (tokens.Peek().Name == symbol)
         return true;
       return false;
     }
 
-    private bool ConsumeToken(string name, bool force) {
+    private bool ConsumeToken(Token.Symbol symbol, bool force) {
       if (tokens.Count == 0)
         if (force)
           throw new ParseError(String.Format(
             "end of input while expecting token \"{0}\"",
-            name));
+            symbol));
         else
           return false;
-      if (tokens.Peek().Name == name) {
+      if (tokens.Peek().Name == symbol) {
         tokens.Dequeue();
         return true;
@@ -402 +408 @@
         throw new ParseError(String.Format(
           "expected \"{0}\" found \"{1}\"",
-          name,
+          symbol,
           tokens.Peek().ToString()));
       } else {