Index: pkg/front_end/lib/src/fasta/scanner/keyword.dart |
diff --git a/pkg/front_end/lib/src/fasta/scanner/keyword.dart b/pkg/front_end/lib/src/fasta/scanner/keyword.dart |
deleted file mode 100644 |
index 430484e737ee1180d654d2880ab3ccbe23492238..0000000000000000000000000000000000000000 |
--- a/pkg/front_end/lib/src/fasta/scanner/keyword.dart |
+++ /dev/null |
@@ -1,315 +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. |
- |
-library fasta.scanner.keywords; |
- |
-import '../../scanner/token.dart' as analyzer; |
- |
-import 'characters.dart' show $a, $z, $A, $Z; |
- |
-import 'precedence.dart' show PrecedenceInfo; |
- |
-import 'precedence.dart' show AS_INFO, IS_INFO, KEYWORD_INFO; |
- |
-/** |
- * A keyword in the Dart programming language. |
- */ |
-class Keyword extends analyzer.Keyword { |
- static const ASSERT = const Keyword("assert"); |
- static const BREAK = const Keyword("break"); |
- static const CASE = const Keyword("case"); |
- static const CATCH = const Keyword("catch"); |
- static const CLASS = const Keyword("class"); |
- static const CONST = const Keyword("const"); |
- static const CONTINUE = const Keyword("continue"); |
- static const DEFAULT = const Keyword("default"); |
- static const DO = const Keyword("do"); |
- static const ELSE = const Keyword("else"); |
- static const ENUM = const Keyword("enum"); |
- static const EXTENDS = const Keyword("extends"); |
- static const FALSE = const Keyword("false"); |
- static const FINAL = const Keyword("final"); |
- static const FINALLY = const Keyword("finally"); |
- static const FOR = const Keyword("for"); |
- static const IF = const Keyword("if"); |
- static const IN = const Keyword("in"); |
- static const NEW = const Keyword("new"); |
- static const NULL = const Keyword("null"); |
- static const RETHROW = const Keyword("rethrow"); |
- static const RETURN = const Keyword("return"); |
- static const SUPER = const Keyword("super"); |
- static const SWITCH = const Keyword("switch"); |
- static const THIS = const Keyword("this"); |
- static const THROW = const Keyword("throw"); |
- static const TRUE = const Keyword("true"); |
- static const TRY = const Keyword("try"); |
- static const VAR = const Keyword("var"); |
- static const VOID = const Keyword("void"); |
- static const WHILE = const Keyword("while"); |
- static const WITH = const Keyword("with"); |
- |
- // TODO(ahe): Don't think this is a reserved word. |
- // See: http://dartbug.com/5579 |
- static const IS = const Keyword("is", info: IS_INFO); |
- |
- static const ABSTRACT = const Keyword("abstract", isBuiltIn: true); |
- static const AS = const Keyword("as", info: AS_INFO, isBuiltIn: true); |
- static const COVARIANT = const Keyword("covariant", isBuiltIn: true); |
- static const DYNAMIC = const Keyword("dynamic", isBuiltIn: true); |
- static const EXPORT = const Keyword("export", isBuiltIn: true); |
- static const EXTERNAL = const Keyword("external", isBuiltIn: true); |
- static const FACTORY = const Keyword("factory", isBuiltIn: true); |
- static const GET = const Keyword("get", isBuiltIn: true); |
- static const IMPLEMENTS = const Keyword("implements", isBuiltIn: true); |
- static const IMPORT = const Keyword("import", isBuiltIn: true); |
- static const LIBRARY = const Keyword("library", isBuiltIn: true); |
- static const OPERATOR = const Keyword("operator", isBuiltIn: true); |
- static const PART = const Keyword("part", isBuiltIn: true); |
- static const SET = const Keyword("set", isBuiltIn: true); |
- static const STATIC = const Keyword("static", isBuiltIn: true); |
- static const TYPEDEF = const Keyword("typedef", isBuiltIn: true); |
- |
- static const ASYNC = const Keyword("async", isPseudo: true); |
- static const AWAIT = const Keyword("await", isPseudo: true); |
- static const DEFERRED = const Keyword("deferred", isBuiltIn: true); |
- static const FUNCTION = const Keyword("Function", isPseudo: true); |
- static const HIDE = const Keyword("hide", isPseudo: true); |
- static const NATIVE = const Keyword("native", isPseudo: true); |
- static const OF = const Keyword("of", isPseudo: true); |
- static const ON = const Keyword("on", isPseudo: true); |
- static const PATCH = const Keyword("patch", isPseudo: true); |
- static const SHOW = const Keyword("show", isPseudo: true); |
- static const SOURCE = const Keyword("source", isPseudo: true); |
- static const SYNC = const Keyword("sync", isPseudo: true); |
- static const YIELD = const Keyword("yield", isPseudo: true); |
- |
- static const List<Keyword> values = const <Keyword>[ |
- ASSERT, |
- BREAK, |
- CASE, |
- CATCH, |
- CLASS, |
- CONST, |
- CONTINUE, |
- DEFAULT, |
- DO, |
- ELSE, |
- ENUM, |
- EXTENDS, |
- FALSE, |
- FINAL, |
- FINALLY, |
- FOR, |
- IF, |
- IN, |
- NEW, |
- NULL, |
- RETHROW, |
- RETURN, |
- SUPER, |
- SWITCH, |
- THIS, |
- THROW, |
- TRUE, |
- TRY, |
- VAR, |
- VOID, |
- WHILE, |
- WITH, |
- // ==== |
- IS, |
- // ==== Built In |
- ABSTRACT, |
- AS, |
- COVARIANT, |
- DEFERRED, |
- DYNAMIC, |
- EXPORT, |
- EXTERNAL, |
- FACTORY, |
- GET, |
- IMPLEMENTS, |
- IMPORT, |
- LIBRARY, |
- OPERATOR, |
- PART, |
- SET, |
- STATIC, |
- TYPEDEF, |
- // ==== Pseudo |
- ASYNC, |
- AWAIT, |
- FUNCTION, |
- HIDE, |
- NATIVE, |
- OF, |
- ON, |
- PATCH, |
- SHOW, |
- SOURCE, |
- SYNC, |
- YIELD, |
- ]; |
- |
- static Map<String, Keyword> _keywords; |
- static Map<String, Keyword> get keywords { |
- if (_keywords == null) { |
- _keywords = computeKeywordMap(); |
- } |
- return _keywords; |
- } |
- |
- const Keyword(String syntax, |
- {bool isPseudo: false, |
- bool isBuiltIn: false, |
- PrecedenceInfo info: KEYWORD_INFO}) |
- : super(syntax, info: info, isBuiltIn: isBuiltIn, isPseudo: isPseudo); |
- |
- static Map<String, Keyword> computeKeywordMap() { |
- Map<String, Keyword> result = new Map<String, Keyword>(); |
- for (Keyword keyword in values) { |
- result[keyword.syntax] = keyword; |
- } |
- return result; |
- } |
-} |
- |
-/** |
- * Abstract state in a state machine for scanning keywords. |
- */ |
-abstract class KeywordState { |
- KeywordState next(int c); |
- KeywordState nextCapital(int c); |
- |
- 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) { |
- bool isLowercase = true; |
- |
- List<KeywordState> table = new List<KeywordState>($z - $A + 1); |
- 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].codeUnitAt(start); |
- if ($A <= c && c <= $Z) { |
- isLowercase = false; |
- } |
- if (chunk != c) { |
- if (chunkStart != -1) { |
- assert(table[chunk - $A] == null); |
- table[chunk - $A] = computeKeywordStateTable( |
- start + 1, strings, chunkStart, i - chunkStart); |
- } |
- chunkStart = i; |
- chunk = c; |
- } |
- } |
- } |
- if (chunkStart != -1) { |
- assert(table[chunk - $A] == null); |
- table[chunk - $A] = computeKeywordStateTable( |
- start + 1, strings, chunkStart, offset + length - chunkStart); |
- } else { |
- assert(length == 1); |
- return new LeafKeywordState(strings[offset]); |
- } |
- String syntax = isLeaf ? strings[offset] : null; |
- if (isLowercase) { |
- table = table.sublist($a - $A); |
- return new LowerCaseArrayKeywordState(table, syntax); |
- } else { |
- return new UpperCaseArrayKeywordState(table, syntax); |
- } |
- } |
-} |
- |
-/** |
- * A state with multiple outgoing transitions. |
- */ |
-abstract class ArrayKeywordState implements KeywordState { |
- final List<KeywordState> table; |
- final Keyword keyword; |
- |
- ArrayKeywordState(this.table, String syntax) |
- : keyword = ((syntax == null) ? null : Keyword.keywords[syntax]); |
- |
- KeywordState next(int c); |
- |
- KeywordState nextCapital(int c); |
- |
- String toString() { |
- StringBuffer sb = new StringBuffer(); |
- sb.write("["); |
- if (keyword != null) { |
- sb.write("*"); |
- sb.write(keyword); |
- sb.write(" "); |
- } |
- List<KeywordState> foo = table; |
- for (int i = 0; i < foo.length; i++) { |
- if (foo[i] != null) { |
- sb.write("${new String.fromCharCodes([i + $a])}: " |
- "${foo[i]}; "); |
- } |
- } |
- sb.write("]"); |
- return sb.toString(); |
- } |
-} |
- |
-class LowerCaseArrayKeywordState extends ArrayKeywordState { |
- LowerCaseArrayKeywordState(List<KeywordState> table, String syntax) |
- : super(table, syntax) { |
- assert(table.length == $z - $a + 1); |
- } |
- |
- KeywordState next(int c) => table[c - $a]; |
- |
- KeywordState nextCapital(int c) => null; |
-} |
- |
-class UpperCaseArrayKeywordState extends ArrayKeywordState { |
- UpperCaseArrayKeywordState(List<KeywordState> table, String syntax) |
- : super(table, syntax) { |
- assert(table.length == $z - $A + 1); |
- } |
- |
- KeywordState next(int c) => table[c - $A]; |
- |
- KeywordState nextCapital(int c) => table[c - $A]; |
-} |
- |
-/** |
- * A state that has no outgoing transitions. |
- */ |
-class LeafKeywordState implements KeywordState { |
- final Keyword keyword; |
- |
- LeafKeywordState(String syntax) : keyword = Keyword.keywords[syntax]; |
- |
- KeywordState next(int c) => null; |
- KeywordState nextCapital(int c) => null; |
- |
- String toString() => keyword.syntax; |
-} |