Calculator App for ChromeOS with fixes for templates/CSS to support this application.

utils/template/tokenkind.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.
 
 // TODO(terry): Need to be consistent with tokens either they're ASCII tokens
 //              e.g., ASTERISK or they're CSS e.g., PSEUDO, COMBINATOR_*.
 class TokenKind {
   // Common shared tokens used in TokenizerBase.
   static final int UNUSED = 0;                  // Unused place holder...
   static final int END_OF_FILE = 1;
@@ skipping 14 matching lines @@
   // Unique tokens.
   static final int LESS_THAN = 15;              // <
   static final int GREATER_THAN = 16;           // >
   static final int SLASH = 17;                  // /
   static final int DOLLAR = 18;                 // $
   static final int HASH = 19;                   // #
   static final int MINUS = 20;                  // -
   static final int EQUAL = 21;                  // =
   static final int DOUBLE_QUOTE = 22;           // "
   static final int SINGLE_QUOTE = 23;           // '
+  static final int ASTERISK = 24;               // *
 
   // WARNING: END_TOKENS must be 1 greater than the last token above (last
   //          character in our list).  Also add to kindToString function and the
   //          constructor for TokenKind.
 
-  static final int END_TOKENS = 24;             // Marker for last token in list
+  static final int END_TOKENS = 25;             // Marker for last token in list
 
   // Synthesized tokens:
 
   static final int END_NO_SCOPE_TAG = 50;       // />
   static final int START_EXPRESSION = 51;       // ${
   static final int START_COMMAND = 52;          // ${#
   static final int END_COMMAND = 53;            // ${/
   static final int EACH_COMMAND = 53;           // ${#each list}
   static final int WITH_COMMAND = 54;           // ${#with object}
   static final int IF_COMMAND = 55;             // ${#if (expression)}
@@ skipping 136 matching lines @@
 
   static bool validTagName(int tokId) {
     return tokId >= TokenKind.START_HTML_ELEMENT &&
       tokId <= TokenKind.END_HTML_ELEMENT;
   }
 
   static final List<Map<int, String>> _KEYWORDS = const [
     const {'type': TokenKind.TEMPLATE_KEYWORD, 'value' : 'template'},
   ];
 
+  static final List<int> _NON_SCOPED_ELEMENTS = const [
+    BR_ELEMENT,
+  ];
+
+  // tag values starting with a minus sign implies tag can be unscoped e.g.,
+  // <br> is valid without <br></br> or <br/>
   static final List<Map<int, String>> _ELEMENTS = const [
     const {'type': TokenKind.A_ELEMENT, 'value' : 'a'},
     const {'type': TokenKind.ABBR_ELEMENT, 'value' : 'abbr'},
     const {'type': TokenKind.ACRONYM_ELEMENT, 'value' : 'acronym'},
     const {'type': TokenKind.ADDRESS_ELEMENT, 'value' : 'address'},
     const {'type': TokenKind.APPLET_ELEMENT, 'value' : 'applet'},
     const {'type': TokenKind.AREA_ELEMENT, 'value' : 'area'},
     const {'type': TokenKind.B_ELEMENT, 'value' : 'b'},
     const {'type': TokenKind.BASE_ELEMENT, 'value' : 'base'},
     const {'type': TokenKind.BASEFONT_ELEMENT, 'value' : 'basefont'},
@@ skipping 112 matching lines @@
         if (match) {
           // Completely matched; return the token for this unit.
           return entry[tokenField];
         }
       }
     }
 
     return -1;  // Not a unit token.
   }
 
-  /* Map _ELEMENTS type to the real name. */
-  static String elementsToName(int kind) {
-    for (final entry in TokenKind._ELEMENTS) {
-      if (kind == entry['type']) {
-        return entry['value'];
-      }
-    }
-  }
-
   /*
    * Return the token that matches the element ident found.
    */
   static int matchElements(String text, int offset, int length) {
     return matchList(_ELEMENTS, 'type', text, offset, length);
   }
 
   static String tagNameFromTokenId(int tagTokenId) {
-    if (tagTokenId >= TokenKind.START_HTML_ELEMENT &&
-        tagTokenId <= TokenKind.END_HTML_ELEMENT) {
+    if (TokenKind.validTagName(tagTokenId)) {
       for (final tag in TokenKind._ELEMENTS) {
         if (tag['type'] == tagTokenId) {
           return tag['value'];
         }
       }
     }
   }
 
+  static bool unscopedTag(int tagTokenId) {
+    for (final tagId in TokenKind._NON_SCOPED_ELEMENTS) {
+      if (tagId == tagTokenId) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   static int matchKeywords(String text, int offset, int length) {
     return matchList(_KEYWORDS, 'type', text, offset, length);
   }
 
   static String kindToString(int kind) {
     switch(kind) {
       case TokenKind.UNUSED: return "ERROR";
       case TokenKind.END_OF_FILE: return "end of file";
       case TokenKind.LPAREN: return "(";
       case TokenKind.RPAREN: return ")";
@@ skipping 10 matching lines @@
       case TokenKind.COMMA: return ",";
       case TokenKind.LESS_THAN: return "<";
       case TokenKind.GREATER_THAN: return ">";
       case TokenKind.SLASH: return "/";
       case TokenKind.DOLLAR: return "\$";
       case TokenKind.HASH: return "#";
       case TokenKind.MINUS: return '-';
       case TokenKind.EQUAL: return '=';
       case TokenKind.DOUBLE_QUOTE: return '"';
       case TokenKind.SINGLE_QUOTE: return "'";
+      case TokenKind.ASTERISK: return "*";
       case TokenKind.END_NO_SCOPE_TAG: return '/>';
       case TokenKind.START_EXPRESSION: return '\${';
       case TokenKind.START_COMMAND: return '\${#';
       case TokenKind.END_COMMAND: return '\${/';
       case TokenKind.EACH_COMMAND: return '\${#each list}';
       case TokenKind.WITH_COMMAND: return '\${with object}';
       case TokenKind.IF_COMMAND: return '\${#if (expression)}';
       case TokenKind.ELSE_COMMAND: return '\${#end}';
       case TokenKind.INTEGER: return 'integer';
       case TokenKind.DOUBLE: return 'double';
@@ skipping 36 matching lines @@
     tokens.add(TokenKind.kindToString(TokenKind.COMMA).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.LESS_THAN).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.GREATER_THAN).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.SLASH).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.DOLLAR).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.HASH).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.MINUS).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.EQUAL).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.DOUBLE_QUOTE).charCodeAt(0));
     tokens.add(TokenKind.kindToString(TokenKind.SINGLE_QUOTE).charCodeAt(0));
+    tokens.add(TokenKind.kindToString(TokenKind.ASTERISK).charCodeAt(0));
 
     assert(tokens.length == TokenKind.END_TOKENS);
   }
 
   static bool isIdentifier(int kind) {
     return kind == IDENTIFIER;
   }
 }
 
 class NoElementMatchException implements Exception {
   String _tagName;
   NoElementMatchException(this._tagName);
 
   String get name() => _tagName;
 }