Move frog/leg to lib/compiler/implementation.

frog/leg/scanner/keyword.dart

Index: frog/leg/scanner/keyword.dart
===================================================================
--- frog/leg/scanner/keyword.dart	(revision 5925)
+++ frog/leg/scanner/keyword.dart	(working copy)
@@ -1,255 +0,0 @@
-// 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");
-  static final Keyword CATCH = const Keyword("catch");
-  static final Keyword CLASS = const Keyword("class");
-  static final Keyword CONST = const Keyword("const");
-  static final Keyword CONTINUE = const Keyword("continue");
-  static final Keyword DEFAULT = const Keyword("default");
-  static final Keyword DO = const Keyword("do");
-  static final Keyword ELSE = const Keyword("else");
-  static final Keyword EXTENDS = const Keyword("extends");
-  static final Keyword FALSE = const Keyword("false");
-  static final Keyword FINAL = const Keyword("final");
-  static final Keyword FINALLY = const Keyword("finally");
-  static final Keyword FOR = const Keyword("for");
-  static final Keyword IF = const Keyword("if");
-  static final Keyword IN = const Keyword("in");
-  static final Keyword IS = const Keyword("is", info: IS_INFO);
-  static final Keyword NEW = const Keyword("new");
-  static final Keyword NULL = const Keyword("null");
-  static final Keyword RETURN = const Keyword("return");
-  static final Keyword SUPER = const Keyword("super");
-  static final Keyword SWITCH = const Keyword("switch");
-  static final Keyword THIS = const Keyword("this");
-  static final Keyword THROW = const Keyword("throw");
-  static final Keyword TRUE = const Keyword("true");
-  static final Keyword TRY = const Keyword("try");
-  static final Keyword VAR = const Keyword("var");
-  static final Keyword VOID = const Keyword("void");
-  static final Keyword WHILE = const Keyword("while");
-
-  // Pseudo keywords:
-  static final Keyword ABSTRACT = const Keyword("abstract", isPseudo: true);
-  static final Keyword ASSERT = const Keyword("assert", isPseudo: true);
-  static final Keyword FACTORY = const Keyword("factory", isPseudo: true);
-  static final Keyword GET = const Keyword("get", isPseudo: true);
-  static final Keyword IMPLEMENTS = const Keyword("implements", isPseudo: true);
-  static final Keyword IMPORT = const Keyword("import", isPseudo: true);
-  static final Keyword INTERFACE = const Keyword("interface", isPseudo: true);
-  static final Keyword LIBRARY = const Keyword("library", isPseudo: true);
-  static final Keyword NATIVE = const Keyword("native", isPseudo: true);
-  static final Keyword NEGATE = const Keyword("negate", isPseudo: true);
-  static final Keyword OPERATOR = const Keyword("operator", isPseudo: true);
-  static final Keyword SET = const Keyword("set", isPseudo: true);
-  static final Keyword SOURCE = const Keyword("source", isPseudo: true);
-  static final Keyword STATIC = const Keyword("static", isPseudo: true);
-  static final Keyword TYPEDEF = const Keyword("typedef", isPseudo: true);
-
-  static final List<Keyword> values = const <Keyword> [
-      BREAK,
-      CASE,
-      CATCH,
-      CONST,
-      CONTINUE,
-      DEFAULT,
-      DO,
-      ELSE,
-      FALSE,
-      FINAL,
-      FINALLY,
-      FOR,
-      IF,
-      IN,
-      IS,
-      NEW,
-      NULL,
-      RETURN,
-      SUPER,
-      SWITCH,
-      THIS,
-      THROW,
-      TRUE,
-      TRY,
-      VAR,
-      VOID,
-      WHILE,
-      ABSTRACT,
-      ASSERT,
-      CLASS,
-      EXTENDS,
-      FACTORY,
-      GET,
-      IMPLEMENTS,
-      IMPORT,
-      INTERFACE,
-      LIBRARY,
-      NATIVE,
-      NEGATE,
-      OPERATOR,
-      SET,
-      SOURCE,
-      STATIC,
-      TYPEDEF ];
-
-  final String syntax;
-  final bool isPseudo;
-  final PrecedenceInfo info;
-
-  static Map<String, Keyword> _keywords;
-  static Map<String, Keyword> get keywords() {
-    if (_keywords === null) {
-      _keywords = computeKeywordMap();
-    }
-    return _keywords;
-  }
-
-  const Keyword(String this.syntax,
-                [bool this.isPseudo = false,
-                 PrecedenceInfo this.info = KEYWORD_INFO]);
-
-  static Map<String, Keyword> computeKeywordMap() {
-    Map<String, Keyword> result = new LinkedHashMap<String, Keyword>();
-    for (Keyword keyword in values) {
-      result[keyword.syntax] = keyword;
-    }
-    return result;
-  }
-
-  int hashCode() => syntax.hashCode();
-
-  bool operator ==(other) {
-    return other is SourceString && toString() == other.slowToString();
-  }
-
-  Iterator<int> iterator() => new StringCodeIterator(syntax);
-
-  void printOn(StringBuffer sb) {
-    sb.add(syntax);
-  }
-
-  String toString() => syntax;
-  String slowToString() => syntax;
-  String get stringValue() => syntax;
-
-  bool isEmpty() => false;
-  bool isPrivate() => false;
-}
-
-/**
- * Abstract state in a state machine for scanning keywords.
- */
-class KeywordState {
-  abstract bool isLeaf();
-  abstract KeywordState next(int c);
-  abstract Keyword get keyword();
-
-  static KeywordState _KEYWORD_STATE;
-  static KeywordState get KEYWORD_STATE() {
-    if (_KEYWORD_STATE === null) {
-      List<String> strings = new List<String>(Keyword.values.length);
-      for (int i = 0; i < Keyword.values.length; i++) {
-        strings[i] = Keyword.values[i].syntax;
-      }
-      strings.sort((a,b) => a.compareTo(b));
-      _KEYWORD_STATE = computeKeywordStateTable(0, strings, 0, strings.length);
-    }
-    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]);
-    }
-    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, String syntax)
-    : keyword = (syntax === null) ? null : Keyword.keywords[syntax];
-
-  bool isLeaf() => false;
-
-  KeywordState next(int c) => table[c - $a];
-
-  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("${new String.fromCharCodes([i + $a])}: ${foo[i]}; ");
-      }
-    }
-    sb.add("]");
-    return sb.toString();
-  }
-}
-
-/**
- * A state that has no outgoing transitions.
- */
-class LeafKeywordState extends KeywordState {
-  final Keyword keyword;
-
-  LeafKeywordState(String syntax) : keyword = Keyword.keywords[syntax];
-
-  bool isLeaf() => true;
-
-  KeywordState next(int c) => null;
-
-  String toString() => keyword.syntax;
-}