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

utils/template/parser.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
 
 class TagStack {
   List<ASTNode> _stack;
 
   TagStack(var elem) : _stack = [] {
     _stack.add(elem);
   }
 
@@ skipping 90 matching lines @@
     _previousToken = _peekToken;
     _peekToken = tokenizer.next(inTag);
     return _previousToken;
   }
 
   bool _peekKind(int kind) {
     return _peekToken.kind == kind;
   }
 
   /* Is the next token a legal identifier?  This includes pseudo-keywords. */
-  bool _peekIdentifier() {
-    return TokenKind.isIdentifier(_peekToken.kind);
+  bool _peekIdentifier([String name = null]) {
+    if (TokenKind.isIdentifier(_peekToken.kind)) {
+      return (name != null) ? _peekToken.text == name : true;
+    }
+
+    return false;
   }
 
   bool _maybeEat(int kind) {
     if (_peekToken.kind == kind) {
       _previousToken = _peekToken;
-      _peekToken = tokenizer.next();
+      if (kind == TokenKind.GREATER_THAN) {
+        _peekToken = tokenizer.next(false);
+      } else {
+        _peekToken = tokenizer.next();
+      }
       return true;
     } else {
       return false;
     }
   }
 
   void _eat(int kind) {
     if (!_maybeEat(kind)) {
       _errorExpected(TokenKind.kindToString(kind));
     }
@@ skipping 72 matching lines @@
         //              List<String> arg1, etc).
         var type = processAsIdentifier();
         var paramName = processAsIdentifier();
         if (type != null && paramName != null) {
           params.add({'type': type, 'name' : paramName});
 
           if (!_maybeEat(TokenKind.COMMA)) {
             break;
           }
         } else {
-          _error("Template paramter missing type and name", _makeSpan(start));
+          // No parameters we're done.
           break;
         }
       }
 
       _eat(TokenKind.RPAREN);
 
       TemplateSignature sig =
         new TemplateSignature(templateName.name, params, _makeSpan(start));
 
       TemplateContent content = processTemplateContent();
@@ skipping 14 matching lines @@
       return identifier();
     } else if (TokenKind.validTagName(_peek())) {
       var tok = _next();
       return new Identifier(TokenKind.tagNameFromTokenId(tok.kind),
         _makeSpan(start));
     }
   }
 
   css.Stylesheet processCSS() {
     // Is there a CSS block?
-    if (_peekIdentifier()) {
+    if (_peekIdentifier('css')) {
+      _next();
+
       int start = _peekToken.start;
-      if (identifier().name == 'css') {
-        _eat(TokenKind.LBRACE);
+      _eat(TokenKind.LBRACE);
 
-        css.Stylesheet cssCtx = processCSSContent(source, tokenizer.startIndex);
+      css.Stylesheet cssCtx = processCSSContent(source, tokenizer.startIndex);
 
-        // TODO(terry): Hack, restart template parser where CSS parser stopped.
-        tokenizer.index = lastCSSIndexParsed;
-       _next(false);
+      // TODO(terry): Hack, restart template parser where CSS parser stopped.
+      tokenizer.index = lastCSSIndexParsed;
+     _next(false);
 
-        _eat(TokenKind.RBRACE);       // close } of css block
+      _eat(TokenKind.RBRACE);       // close } of css block
 
-        return cssCtx;
+      return cssCtx;
+    }
+  }
+
+  // TODO(terry): get should be able to use all template control flow but return
+  //              a string instead of a node.  Maybe expose both html and get
+  //              e.g.,
+  //
+  //              A.)
+  //              html {
+  //                <div>...</div>
+  //              }
+  //
+  //              B.)
+  //              html foo() {
+  //                <div>..</div>
+  //              }
+  //
+  //              C.)
+  //              get {
+  //                <div>...</div>
+  //              }
+  //
+  //              D.)
+  //              get foo() {
+  //                <div>..</div>
+  //              }
+  //
+  //              Only one default allower either A or C the constructor will
+  //              generate a string or a node.
+  //              Examples B and D would generate getters that either return
+  //              a node for B or a String for D.
+  //
+  List<TemplateGetter> processGetters() {
+    List<TemplateGetter> getters = [];
+
+    while (true) {
+      if (_peekIdentifier('get')) {
+        _next();
+
+        int start = _peekToken.start;
+        if (_peekIdentifier()) {
+          String getterName = identifier().name;
+
+          List<Map<Identifier, Identifier>> params =
+            new List<Map<Identifier, Identifier>>();
+
+          _eat(TokenKind.LPAREN);
+
+          start = _peekToken.start;
+          while (true) {
+            // TODO(terry): Need robust Dart argument parser (e.g.,
+            //              List<String> arg1, etc).
+            var type = processAsIdentifier();
+            var paramName = processAsIdentifier();
+            if (paramName == null && type != null) {
+              paramName = type;
+              type = "";
+            }
+            if (type != null && paramName != null) {
+              params.add({'type': type, 'name' : paramName});
+
+              if (!_maybeEat(TokenKind.COMMA)) {
+                break;
+              }
+            } else {
+              // No parameters we're done.
+              break;
+            }
+          }
+
+          _eat(TokenKind.RPAREN);
+
+          _eat(TokenKind.LBRACE);
+
+          var elems = new TemplateElement.fragment(_makeSpan(_peekToken.start));
+          var templateDoc = processHTML(elems);
+
+          _eat(TokenKind.RBRACE);       // close } of get block
+
+          getters.add(new TemplateGetter(getterName, params, templateDoc,
+            _makeSpan(_peekToken.start)));
+        }
+      } else {
+        break;
       }
     }
+
+    return getters;
+
+/*
+    get newTotal(value) {
+      <div class="alignleft">${value}</div>
+    }
+
+    String get HTML_newTotal(value) {
+      return '<div class="alignleft">${value}</div>
+    }
+
+*/
   }
+
   TemplateContent processTemplateContent() {
-    css.Stylesheet stylesheet;
+    css.Stylesheet ss;
 
     _eat(TokenKind.LBRACE);
 
     int start = _peekToken.start;
 
-    stylesheet = processCSS();
+    ss = processCSS();
+
+    // TODO(terry): getters should be allowed anywhere not just after CSS.
+    List<TemplateGetter> getters = processGetters();
 
     var elems = new TemplateElement.fragment(_makeSpan(_peekToken.start));
     var templateDoc = processHTML(elems);
 
     // TODO(terry): Should allow css { } to be at beginning or end of the
     //              template's content.  Today css only allow at beginning
     //              because the css {...} is sucked in as a text node.  We'll
     //              need a special escape for css maybe:
     //
     //                  ${#css}
     //                  ${/css}
     //
     //              uggggly!
 
+
     _eat(TokenKind.RBRACE);
 
-    return new TemplateContent(stylesheet, templateDoc, _makeSpan(start));
+    return new TemplateContent(ss, templateDoc, getters, _makeSpan(start));
   }
 
   int lastCSSIndexParsed;       // TODO(terry): Hack, last good CSS parsed.
 
   css.Stylesheet processCSSContent(var cssSource, int start) {
     try {
       css.Parser parser = new css.Parser(new SourceFile(
           SourceFile.IN_MEMORY_FILE, cssSource.text), start);
 
       css.Stylesheet stylesheet = parser.parse(false, new ErrorMsgRedirector());
@@ skipping 30 matching lines @@
           Map<String, TemplateAttribute> attrs = processAttributes();
 
           String varName;
           if (attrs.containsKey('var')) {
             varName = attrs['var'].value;
             attrs.remove('var');
           }
 
           int scopeType;     // 1 implies scoped, 2 implies non-scoped element.
           if (_maybeEat(TokenKind.GREATER_THAN)) {
-            scopeType = 1;
+            // Scoped unless the tag is explicitly known as an unscoped tag
+            // e.g., <br>.
+            scopeType = TokenKind.unscopedTag(tagToken.kind) ? 2 : 1;
           } else if (_maybeEat(TokenKind.END_NO_SCOPE_TAG)) {
             scopeType = 2;
           }
           if (scopeType > 0) {
             var elem = new TemplateElement.attributes(tagToken.kind,
               attrs.getValues(), varName, _makeSpan(start));
             stack.top().add(elem);
 
             if (scopeType == 1) {
               // Maybe more nested tags/text?
@@ skipping 148 matching lines @@
 
   /* Map is used so only last unique attribute name is remembered and to quickly
    * find the var attribute.
    */
   Map<String, TemplateAttribute> processAttributes() {
     Map<String, TemplateAttribute> attrs = new Map();
 
     int start = _peekToken.start;
     String elemName;
     while (_peekIdentifier() ||
-           (elemName = TokenKind.elementsToName(_peek())) != null) {
+           (elemName = TokenKind.tagNameFromTokenId(_peek())) != null) {
       var attrName;
       if (elemName == null) {
         attrName = identifier();
       } else {
         attrName = new Identifier(elemName, _makeSpan(start));
         _next();
       }
 
       var attrValue;
 
@@ skipping 41 matching lines @@
         _next(false);
       } else if (_peek() != TokenKind.RBRACE) {
         // Yes, grab the chars after the >
         stringValue.add(_previousToken.source.text.substring(
             this._previousToken.end, this._peekToken.start));
       }
     }
 
     // Gobble up everything until we hit <
     while (_peek() != TokenKind.LESS_THAN &&
+           _peek() != TokenKind.START_COMMAND &&
+           _peek() != TokenKind.END_COMMAND &&
            (_peek() != TokenKind.RBRACE ||
             (_peek() == TokenKind.RBRACE && inExpression)) &&
            _peek() != TokenKind.END_OF_FILE) {
 
       // Beginning of expression?
       if (_peek() == TokenKind.START_EXPRESSION) {
         if (stringValue.length > 0) {
           // We have a real text node create the text node.
           nodes.add(new TemplateText(stringValue.toString(), _makeSpan(start)));
           stringValue = new StringBuffer();
@@ skipping 17 matching lines @@
     }
 
     if (stringValue.length > 0) {
       nodes.add(new TemplateText(stringValue.toString(), _makeSpan(start)));
     }
 
     return nodes;
   }
 
 }