Various scanner fixes:

dart/frog/leg/scanner/keyword.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * A keyword in the Dart programming language.
  */
 class Keyword implements SourceString {
   static final Keyword BREAK = const Keyword("break");
   static final Keyword CASE = const Keyword("case");
@@ skipping 143 matching lines @@
     }
     return _KEYWORD_STATE;
   }
 
   static KeywordState computeKeywordStateTable(int start, List<String> strings,
                                                int offset, int length) {
     List<KeywordState> result = new List<KeywordState>(26);
     assert(length != 0);
     int chunk = 0;
     int chunkStart = -1;
+    bool isLeaf = false;
     for (int i = offset; i < offset + length; i++) {
+      if (strings[i].length == start) {
+        isLeaf = true;
+      }
       if (strings[i].length > start) {
         int c = strings[i].charCodeAt(start);
         if (chunk != c) {
           if (chunkStart != -1) {
+            assert(result[chunk - $a] === null);
             result[chunk - $a] = computeKeywordStateTable(start + 1, strings,
                                                           chunkStart,
                                                           i - chunkStart);
           }
           chunkStart = i;
           chunk = c;
         }
       }
     }
     if (chunkStart != -1) {
+      assert(result[chunk - $a] === null);
       result[chunk - $a] =
         computeKeywordStateTable(start + 1, strings, chunkStart,
                                  offset + length - chunkStart);
     } else {
       assert(length == 1);
       return new LeafKeywordState(strings[offset]);
     }
-    return new ArrayKeywordState(result);
+    if (isLeaf) {
+      return new ArrayKeywordState(result, strings[offset]);
+    } else {
+      return new ArrayKeywordState(result, null);
+    }
   }
 }
 
 /**
  * A state with multiple outgoing transitions.
  */
 class ArrayKeywordState extends KeywordState {
   final List<KeywordState> table;
+  final Keyword keyword;
 
-  ArrayKeywordState(List<KeywordState> this.table);
+  ArrayKeywordState(List<KeywordState> this.table, String syntax)
+    : keyword = (syntax === null) ? null : Keyword.keywords[syntax];
 
   bool isLeaf() => false;
 
   KeywordState next(int c) => table[c - $a];
 
-  Keyword get keyword() {
-    throw "should not be called";
-  }
-
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.add("[");
+    if (keyword !== null) {
+      sb.add("*");
+      sb.add(keyword);
+      sb.add(" ");
+    }
     List<KeywordState> foo = table;
     for (int i = 0; i < foo.length; i++) {
       if (foo[i] != null) {
-        sb.add("${i + $a}: ${foo[i]}; ");
+        sb.add("${new String.fromCharCodes([i + $a])}: ${foo[i]}; ");
       }
     }
     sb.add("]");
     return sb.toString();
   }
 }
 
 /**
  * A state that has no outgoing transitions.
  */
 class LeafKeywordState extends KeywordState {
-  Keyword keyword;
+  final Keyword keyword;
 
   LeafKeywordState(String syntax) : keyword = Keyword.keywords[syntax];
 
   bool isLeaf() => true;
 
   KeywordState next(int c) => null;
 
   String toString() => keyword.syntax;
 }