[html5lib] triple slash comment style

pkg/third_party/html5lib/lib/src/tokenizer.dart

 library tokenizer;
 
 import 'dart:collection';
 import 'package:html5lib/parser.dart' show HtmlParser;
 import 'package:source_maps/span.dart' show Span, FileSpan;
 import 'constants.dart';
 import 'inputstream.dart';
 import 'token.dart';
 import 'utils.dart';
 
 // Group entities by their first character, for faster lookups
 
 // TODO(jmesserly): we could use a better data structure here like a trie, if
 // we had it implemented in Dart.
 Map<String, List<String>> entitiesByFirstChar = (() {
   var result = {};
   for (var k in entities.keys) {
     result.putIfAbsent(k[0], () => []).add(k);
   }
   return result;
 })();
 
 // TODO(jmesserly): lots of ways to make this faster:
 // - use char codes everywhere instead of 1-char strings
 // - use switch instead of contains, indexOf
 // - use switch instead of the sequential if tests
 // - avoid string concat
 
-/**
- * This class takes care of tokenizing HTML.
- */
+/// This class takes care of tokenizing HTML.
 class HtmlTokenizer implements Iterator<Token> {
   // TODO(jmesserly): a lot of these could be made private
 
   final HtmlInputStream stream;
 
   final bool lowercaseElementName;
 
   final bool lowercaseAttrName;
 
-  /** True to generate spans in for [Token.span]. */
+  /// True to generate spans in for [Token.span].
   final bool generateSpans;
 
-  /** True to generate spans for attributes. */
+  /// True to generate spans for attributes.
   final bool attributeSpans;
 
-  /**
-   * This reference to the parser is used for correct CDATA handling.
-   * The [HtmlParser] will set this at construction time.
-   */
+  /// This reference to the parser is used for correct CDATA handling.
+  /// The [HtmlParser] will set this at construction time.
   HtmlParser parser;
 
   final Queue<Token> tokenQueue;
 
-  /** Holds the token that is currently being processed. */
+  /// Holds the token that is currently being processed.
   Token currentToken;
 
-  /**
-   * Holds a reference to the method to be invoked for the next parser state.
-   */
+  /// Holds a reference to the method to be invoked for the next parser state.
   // TODO(jmesserly): the type should be "Predicate" but a dart2js checked mode
   // bug prevents us from doing that. See http://dartbug.com/12465
   Function state;
 
   String temporaryBuffer;
 
   int _lastOffset;
 
   // TODO(jmesserly): ideally this would be a LinkedHashMap and we wouldn't add
   // an item until it's ready. But the code doesn't have a clear notion of when
@@ skipping 46 matching lines @@
   // Note: we could track the name span here, if we need it.
   void _markAttributeNameEnd(int offset) => _markAttributeEnd(offset);
 
   void _addAttribute(String name) {
     if (_attributes == null) _attributes = [];
     var attr = new TagAttribute(name);
     _attributes.add(attr);
     if (attributeSpans) attr.start = stream.position - name.length;
   }
 
-  /**
-   * This is where the magic happens.
-   *
-   * We do our usually processing through the states and when we have a token
-   * to return we yield the token which pauses processing until the next token
-   * is requested.
-   */
+  /// This is where the magic happens.
+  ///
+  /// We do our usually processing through the states and when we have a token
+  /// to return we yield the token which pauses processing until the next token
+  /// is requested.
   bool moveNext() {
     // Start processing. When EOF is reached state will return false;
     // instead of true and the loop will terminate.
     while (stream.errors.length == 0 && tokenQueue.length == 0) {
       if (!state()) {
         _current = null;
         return false;
       }
     }
     if (stream.errors.length > 0) {
       _current = new ParseErrorToken(stream.errors.removeFirst());
     } else {
       assert (tokenQueue.length > 0);
       _current = tokenQueue.removeFirst();
     }
     return true;
   }
 
-  /**
-   * Resets the tokenizer state. Calling this does not reset the [stream] or
-   * the [parser].
-   */
+  /// Resets the tokenizer state. Calling this does not reset the [stream] or
+  /// the [parser].
   void reset() {
     _lastOffset = 0;
     tokenQueue.clear();
     currentToken = null;
     temporaryBuffer = null;
     _attributes = null;
     _attributeNames = null;
     state = dataState;
   }
 
-  /** Adds a token to the queue. Sets the span if needed. */
+  /// Adds a token to the queue. Sets the span if needed.
   void _addToken(Token token) {
     if (generateSpans && token.span == null) {
       int offset = stream.position;
       token.span = new FileSpan(stream.fileInfo, _lastOffset, offset);
       if (token is! ParseErrorToken) {
         _lastOffset = offset;
       }
     }
     tokenQueue.add(token);
   }
 
-  /**
-   * This function returns either U+FFFD or the character based on the
-   * decimal or hexadecimal representation. It also discards ";" if present.
-   * If not present it will add a [ParseErrorToken].
-   */
+  /// This function returns either U+FFFD or the character based on the
+  /// decimal or hexadecimal representation. It also discards ";" if present.
+  /// If not present it will add a [ParseErrorToken].
   String consumeNumberEntity(bool isHex) {
     var allowed = isDigit;
     var radix = 10;
     if (isHex) {
       allowed = isHexDigit;
       radix = 16;
     }
 
     var charStack = [];
 
@@ skipping 145 matching lines @@
       var token;
       if (isWhitespace(output)) {
         token = new SpaceCharactersToken(output);
       } else {
         token = new CharactersToken(output);
       }
       _addToken(token);
     }
   }
 
-  /** This method replaces the need for "entityInAttributeValueState". */
+  /// This method replaces the need for "entityInAttributeValueState".
   void processEntityInAttribute(String allowedChar) {
     consumeEntity(allowedChar: allowedChar, fromAttribute: true);
   }
 
-  /**
-   * This method is a generic handler for emitting the tags. It also sets
-   * the state to "data" because that's what's needed after a token has been
-   * emitted.
-   */
+  /// This method is a generic handler for emitting the tags. It also sets
+  /// the state to "data" because that's what's needed after a token has been
+  /// emitted.
   void emitCurrentToken() {
     var token = currentToken;
     // Add token to the queue to be yielded
     if (token is TagToken) {
       if (lowercaseElementName) {
         token.name = asciiUpper2Lower(token.name);
       }
       if (token is EndTagToken) {
         if (_attributes != null) {
           _addToken(new ParseErrorToken("attributes-in-end-tag"));
@@ skipping 1524 matching lines @@
     }
 
     if (data.length > 0) {
       _addToken(new CharactersToken(data.join()));
     }
     state = dataState;
     return true;
   }
 }