Template parser

utils/css/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
 
 /**
  * A simple recursive descent parser for CSS.
  */
 class Parser {
   Tokenizer tokenizer;
 
   var _fs;                        // If non-null filesystem to read files.
   String _basePath;               // Base path of CSS file.
 
-  final lang.SourceFile source;
+  final SourceFile source;
 
-  lang.Token _previousToken;
-  lang.Token _peekToken;
-  
+  Token _previousToken;
+  Token _peekToken;
+
+// Communicating errors back to template parser.
+// TODO(terry): Need a better mechanism (e.g., common World).
+  var _erroMsgRedirector;
+
   Parser(this.source, [int start = 0, this._fs = null, this._basePath = null]) {
     tokenizer = new Tokenizer(source, true, start);
     _peekToken = tokenizer.next();
     _previousToken = null;
   }
 
   // Main entry point for parsing an entire CSS file.
-  Stylesheet parse() {
-    List<lang.Node> productions = [];
+  // If nestedCSS is true when we're back at processing directives from top and
+  // we encounter a } then stop we're inside of a template e.g.,
+  //
+  //       template ... {
+  //          css {
+  //            .item {
+  //               left: 10px;
+  //            }
+  //          }
+  //          <div>...</div>
+  //       }
+  // 
+  Stylesheet parse([bool nestedCSS = false, var erroMsgRedirector = null]) {
+    // TODO(terry): Hack for migrating CSS errors back to template errors.
+    _erroMsgRedirector = erroMsgRedirector;
+
+    List<ASTNode> productions = [];
 
     int start = _peekToken.start;
-    while (!_maybeEat(TokenKind.END_OF_FILE)) {
+    while (!_maybeEat(TokenKind.END_OF_FILE) &&
+           (!nestedCSS && !_peekKind(TokenKind.RBRACE))) {
       // TODO(terry): Need to handle charset, import, media and page.
       var directive = processDirective();
       if (directive != null) {
         productions.add(directive);
       } else {
-        productions.add(processRuleSet());
+        RuleSet ruleset = processRuleSet();
+        if (ruleset != null) {
+          productions.add(ruleset);
+        } else {
+          break;
+        }
       }
     }
 
     return new Stylesheet(productions, _makeSpan(start));
   }
 
   /** Generate an error if [source] has not been completely consumed. */
   void checkEndOfFile() {
     _eat(TokenKind.END_OF_FILE);
   }
@@ skipping 11 matching lines @@
     }
   }
 
   ///////////////////////////////////////////////////////////////////
   // Basic support methods
   ///////////////////////////////////////////////////////////////////
   int _peek() {
     return _peekToken.kind;
   }
 
-  lang.Token _next() {
+  Token _next() {
     _previousToken = _peekToken;
     _peekToken = tokenizer.next();
     return _previousToken;
   }
 
   bool _peekKind(int kind) {
     return _peekToken.kind == kind;
   }
 
   /* Is the next token a legal identifier?  This includes pseudo-keywords. */
@@ skipping 25 matching lines @@
     var tok = _next();
     var message;
     try {
       message = 'expected $expected, but found $tok';
     } catch (final e) {
       message = 'parsing error expected $expected';
     }
     _error(message, tok.span);
   }
 
-  void _error(String message, [lang.SourceSpan location=null]) {
+  void _error(String message, [SourceSpan location=null]) {
     if (location === null) {
       location = _peekToken.span;
     }
 
-    lang.world.fatal(message, location);    // syntax errors are fatal for now
+    if (_erroMsgRedirector == null) {
+       world.fatal(message, location);    // syntax errors are fatal for now
+    } else {
+      String text = "";
+      if (location != null) {
+        text = location.toMessageString("");
+      }
+      _erroMsgRedirector.displayError("CSS error: \r${text}\r${message}");
+    }
   }
 
-  void _warning(String message, [lang.SourceSpan location=null]) {
+  void _warning(String message, [SourceSpan location=null]) {
     if (location === null) {
       location = _peekToken.span;
     }
 
-    lang.world.warning(message, location);
+    world.warning(message, location);
   }
 
-  lang.SourceSpan _makeSpan(int start) {
-    return new lang.SourceSpan(source, start, _previousToken.end);
+  SourceSpan _makeSpan(int start) {
+    return new SourceSpan(source, start, _previousToken.end);
   }
 
   ///////////////////////////////////////////////////////////////////
   // Top level productions
   ///////////////////////////////////////////////////////////////////
 
   // Templates are @{selectors} single line nothing else.
   SelectorGroup parseTemplate() {
     SelectorGroup selectorGroup = null;
     if (!isPrematureEndOfFile()) {
@@ skipping 165 matching lines @@
           if (_fs.fileExists('${_basePath}${filename}')) {
             String basePath = "";
             int idx = filename.lastIndexOf('/');
             if (idx >= 0) {
               basePath = filename.substring(0, idx + 1);
             }
             basePath = '${_basePath}${basePath}';
             // Yes, let's parse this file as well.
             String fullFN = '${basePath}${filename}';
             String contents = _fs.readAll(fullFN);
-            Parser parser = new Parser(new lang.SourceFile(fullFN, contents), 0,
+            Parser parser = new Parser(new SourceFile(fullFN, contents), 0,
                 _fs, basePath);
             Stylesheet stylesheet = parser.parse();
             return new IncludeDirective(filename, stylesheet, _makeSpan(start));
           }
 
           _error('file doesn\'t exist ${filename}', _peekToken.span);
         }
 
         print("WARNING: @include doesn't work for uitest");
         return new IncludeDirective(filename, null, _makeSpan(start));
       case TokenKind.DIRECTIVE_STYLET:
         /* Stylet grammar:
         *
         *  @stylet IDENT '{'
         *    ruleset
         *  '}'
         */
         _next();
 
         var name;
         if (_peekIdentifier()) {
           name = identifier();
         }
 
         _eat(TokenKind.LBRACE);
 
-        List<lang.Node> productions = [];
+        List<ASTNode> productions = [];
 
-        int start = _peekToken.start;
+        start = _peekToken.start;
         while (!_maybeEat(TokenKind.END_OF_FILE)) {
           RuleSet ruleset = processRuleSet();
           if (ruleset == null) {
             break;
           }
           productions.add(ruleset);
         }
 
         _eat(TokenKind.RBRACE);
 
         return new StyletDirective(name, productions, _makeSpan(start));
       default:
         _error('unknown directive, found $_peekToken', _peekToken.span);
       }
     }
   }
 
-  processRuleSet() {
+  RuleSet processRuleSet() {
     int start = _peekToken.start;
 
     SelectorGroup selGroup = processSelectorGroup();
     if (selGroup != null) {
       return new RuleSet(selGroup, processDeclarations(), _makeSpan(start));
     }
   }
 
   DeclarationGroup processDeclarations() {
     int start = _peekToken.start;
@@ skipping 317 matching lines @@
   //  LENGTH:       {num}['px' | 'cm' | 'mm' | 'in' | 'pt' | 'pc']
   //  EMS:          {num}'em'
   //  EXS:          {num}'ex'
   //  ANGLE:        {num}['deg' | 'rad' | 'grad']
   //  TIME:         {num}['ms' | 's']
   //  FREQ:         {num}['hz' | 'khz']
   //  function:     IDENT '(' expr ')'
   //
   processTerm() {
     int start = _peekToken.start;
-    lang.Token t;             // token for term's value
+    Token t;             // token for term's value
     var value;                // value of term (numeric values)
 
     var unary = "";
 
     switch (_peek()) {
     case TokenKind.HASH:
       this._eat(TokenKind.HASH);
       String hexText;
       if (_peekKind(TokenKind.INTEGER)) {
         String hexText1 = _peekToken.text;
@@ skipping 59 matching lines @@
         // FUNCTION
         return processFunction(nameValue);
       } else {
         // TODO(terry): Need to have a list of known identifiers today only
         //              'from' is special.
         if (nameValue.name == 'from') {
           return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
         }
 
         // What kind of identifier is it?
-        int value;
         try {
           // Named color?
-          value = TokenKind.matchColorName(nameValue.name);
+          int colorValue = TokenKind.matchColorName(nameValue.name);
 
           // Yes, process the color as an RGB value.
-          String rgbColor = TokenKind.decimalToHex(value);
-          int value;
+          String rgbColor = TokenKind.decimalToHex(colorValue);
           try {
-            value = parseHex(rgbColor);
+            colorValue = parseHex(rgbColor);
           } catch (HexNumberException hne) {
             _error('Bad hex number', _makeSpan(start));
           }
-          return new HexColorTerm(value, rgbColor, _makeSpan(start));
+          return new HexColorTerm(colorValue, rgbColor, _makeSpan(start));
         } catch (final error) {
           if (error is NoColorMatchException) {
             // TODO(terry): Other named things to match with validator?
-            _warning('Unknown property value ${error.name}', _makeSpan(start));
+
+            // TODO(terry): Disable call to _warning need one World class for
+            //              both CSS parser and other parser (e.g., template)
+            //              so all warnings, errors, options, etc. are driven
+            //              from the one World.
+//          _warning('Unknown property value ${error.name}', _makeSpan(start));
             return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
           }
         }
       }
     }
 
     var term;
     var unitType = this._peek();
 
     switch (unitType) {
@@ skipping 162 matching lines @@
 
     return result;
   }
 }
 
 /** Not a hex number. */
 class HexNumberException implements Exception {
   HexNumberException();
 }