Format all files under tools and utils directory.

tools/addlatexhash.dart

 #!/usr/bin/env dart
 // Copyright (c) 2014, 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.
 //
 // ----------------------------------------------------------------------
 // This is a very specialized tool which was created in order to support
 // adding hash values used as location markers in the LaTeX source of the
 // language specification.  It is intended to take its input file as the
 // first argument, an output file name as the second argument, and a
 // hash listing file name as the third argument. From docs/language a
 // typical usage would be as follows:
 //
 //   dart
-//     --package-root=<build dir>/packages \ 
+//     --package-root=<build dir>/packages \
 //     ../../tools/addlatexhash.dart dartLangSpec.tex out.tex hash.txt
 //
 // This will produce a normalized variant out.tex of the language
 // specification with hash values filled in, and a listing hash.txt of
 // all the hash values along with the label of their textual context
 // (section, subsection, subsubsection, paragraph) .  For more details,
 // please check the language specification source itself.
 //
 // NB: This utility assumes UN*X style line endings, \n, in the LaTeX
 // source file receieved as input; it will not work with other styles.
 
 import 'dart:io';
 import 'dart:convert';
 
 import 'package:crypto/crypto.dart';
 import 'package:convert/convert.dart';
 import 'package:utf/utf.dart';
 
 // ----------------------------------------------------------------------
 // Normalization of the text: removal or normalization of parts that
 // do not affect the output from latex, such as white space.
 
-final commentRE = new RegExp(r"[^\\]%.*");  // NB: . does not match \n.
+final commentRE = new RegExp(r"[^\\]%.*"); // NB: . does not match \n.
 final whitespaceAllRE = new RegExp(r"^\s+$");
-final whitespaceRE = new RegExp(r"(?:(?=\s).){2,}");  // \s except end-of-line
+final whitespaceRE = new RegExp(r"(?:(?=\s).){2,}"); // \s except end-of-line
 
 /// Removes [match]ing part of [line], adjusting that part with the
 /// given [startOffset] and [endOffset], bounded to be valid indices
 /// into the string if needed, then inserts [glue] where text was
 /// removed.  If there is no match then [line] is returned.
 cutMatch(line, match, {startOffset: 0, endOffset: 0, glue: ""}) {
   if (match == null) return line;
   var start = match.start + startOffset;
   var end = match.end + endOffset;
   var len = line.length;
   if (start < 0) start = 0;
   if (end > len) end = len;
   return line.substring(0, start) + glue + line.substring(end);
 }
 
 cutRegexp(line, re, {startOffset: 0, endOffset: 0, glue: ""}) {
   return cutMatch(line, re.firstMatch(line),
-                  startOffset: startOffset,
-                  endOffset: endOffset,
-                  glue: glue);
+      startOffset: startOffset, endOffset: endOffset, glue: glue);
 }
 
 /// Removes the rest of [line] starting from the beginning of the
 /// given [match], and adjusting with the given [offset].  If there
 /// is no match then [line] is returned.
 cutFromMatch(line, match, {offset: 0, glue: ""}) {
   if (match == null) return line;
   return line.substring(0, match.start + offset) + glue;
 }
 
@@ skipping 36 matching lines @@
   var trimLine = line.trimLeft();
   if (trimLine.isEmpty) return justEol(line);
   return trimLine.replaceAll(whitespaceRE, " ");
 }
 
 /// Reduces sequences of >1 white-space-only lines in [lines] to 1,
 /// and sequences of >1 comment-only lines to 1.  Treats comment-only
 /// lines as white-space-only when they occur in white-space-only
 /// line blocks.
 multilineNormalize(lines) {
-  var afterBlankLines = false;    // Does [line] succeed >0 empty lines?
-  var afterCommentLines = false;  // Does [line] succeed >0 commentOnly lines?
+  var afterBlankLines = false; // Does [line] succeed >0 empty lines?
+  var afterCommentLines = false; // Does [line] succeed >0 commentOnly lines?
   var newLines = new List();
   for (var line in lines) {
     if (afterBlankLines && afterCommentLines) {
       // Previous line was both blank and a comment: not possible.
       throw "Bug, please report to eernst@";
     } else if (afterBlankLines && !afterCommentLines) {
       // At least one line before [line] is wsOnly.
       if (!isWsOnly(line)) {
         // Blank line block ended.
         afterCommentLines = isCommentOnly(line);
@@ skipping 45 matching lines @@
 /// Selects the elements in the normalization pipeline.
 normalize(line) => normalizeWhitespace(stripComment(line));
 
 /// Selects the elements in the significant-spacing block
 /// normalization pipeline.
 sispNormalize(line) => stripComment(line);
 
 // Managing fragments with significant spacing.
 
 final dartCodeBeginRE = new RegExp(r"^\s*\\begin\s*\{dartCode\}");
-final dartCodeEndRE = new RegExp (r"^\s*\\end\s*\{dartCode\}");
+final dartCodeEndRE = new RegExp(r"^\s*\\end\s*\{dartCode\}");
 
 /// Recognizes beginning of dartCode block.
 sispIsDartBegin(line) => line.contains(dartCodeBeginRE);
 
 /// Recognizes end of dartCode block.
 sispIsDartEnd(line) => line.contains(dartCodeEndRE);
 
 // ----------------------------------------------------------------------
 // Analyzing the input to point out "interesting" lines
 
@@ skipping 70 matching lines @@
 
   /// Returns null except for \LMHash{} events, where it returns
   /// the startLineNumber.  This serves to specify a boundary because
   /// the preceding \LMHash{} block should stop before the line of
   /// this \LMHash{} command.  Note that hash blocks may stop earlier,
   /// because they cannot contain sectioning commands.
   getStartLineNumber() => null;
 }
 
 class HashMarkerEvent extends HashEvent {
-
   // Line number of first line in block that gets hashed.
   var startLineNumber;
 
   // Highest possible number of first line after block that gets
   // hashed (where the next \LMHash{} occurs).  Note that this value
   // is not known initially (because that line has not yet been
   // reached), so [endLineNumber] will be initialized in a separate
   // scan.  Also note that the block may end earlier, because a block
   // ends if it would otherwise include a sectioning command.
   var endLineNumber;
 
   HashMarkerEvent(this.startLineNumber);
 
-  setEndLineNumber(n) { endLineNumber = n; }
+  setEndLineNumber(n) {
+    endLineNumber = n;
+  }
+
   getStartLineNumber() => startLineNumber;
 }
 
 class HashLabelEvent extends HashEvent {
   var labelText;
   HashLabelEvent(this.labelText);
 }
 
 class HashAnalyzer {
   // List of kinds of pending (= most recently seen) sectioning command.
@@ skipping 24 matching lines @@
   setPendingToParagraph() {
     pendingSectioning = PENDING_IS_PARAGRAPH;
   }
 
   clearPending() {
     pendingSectioning = PENDING_IS_NONE;
   }
 
   sectioningPrefix() {
     switch (pendingSectioning) {
-      case PENDING_IS_SECTION: return "sec:";
-      case PENDING_IS_SUBSECTION: return "subsec:";
-      case PENDING_IS_SUBSUBSECTION: return "subsubsec:";
-      case PENDING_IS_PARAGRAPH: return "par:";
+      case PENDING_IS_SECTION:
+        return "sec:";
+      case PENDING_IS_SUBSECTION:
+        return "subsec:";
+      case PENDING_IS_SUBSUBSECTION:
+        return "subsubsec:";
+      case PENDING_IS_PARAGRAPH:
+        return "par:";
       case PENDING_IS_NONE:
-        throw
-            "\\LMHash{..} should only be used after a sectioning command " +
+        throw "\\LMHash{..} should only be used after a sectioning command " +
             "(\\section, \\subsection, \\subsubsection, \\paragraph)";
       default:
         // set of PENDING_IS_.. was extended, but updates here omitted
         throw "Bug, please report to eernst@";
     }
   }
 
   analyze(line) {
     var currentLineNumber = lineNumber++;
     if (isHashMarker(line)) {
@@ skipping 35 matching lines @@
 // ----------------------------------------------------------------------
 // Removal of non-normative elements of the text (rationale, commentary).
 
 /// Returns [line] without the command [cmdName] (based on a match
 /// on "\\cmdName\s*{..}") starting at [startIndex]; note that it is
 /// assumed but not checked that [line] contains "\\cmdType\s*{..",
 /// and note that the end of the {..} block is found via brace matching
 /// (i.e., nested {..} blocks are handled), but it may break if '{' is
 /// made an active character etc.etc.
 removeCommand(line, cmdName, startIndex) {
-  const BACKSLASH = 92;     // char code for '\\'.
-  const BRACE_BEGIN = 123;  // char code for '{'.
-  const BRACE_END = 125;    // char code for '}'.
+  const BACKSLASH = 92; // char code for '\\'.
+  const BRACE_BEGIN = 123; // char code for '{'.
+  const BRACE_END = 125; // char code for '}'.
 
   var blockStartIndex = startIndex + cmdName.length + 1;
   while (blockStartIndex < line.length &&
-         line.codeUnitAt(blockStartIndex) != BRACE_BEGIN) {
+      line.codeUnitAt(blockStartIndex) != BRACE_BEGIN) {
     blockStartIndex++;
   }
   blockStartIndex++;
   if (blockStartIndex > line.length) {
     throw "Bug, please report to eernst@";
   }
   // [blockStartIndex] has index just after '{'.
 
-  var afterEscape = false;  // Is true iff [index] is just after '{'.
-  var braceLevel = 1;       // Have seen so many '{'s minus so many '}'s.
+  var afterEscape = false; // Is true iff [index] is just after '{'.
+  var braceLevel = 1; // Have seen so many '{'s minus so many '}'s.
 
   for (var index = blockStartIndex; index < line.length; index++) {
     switch (line.codeUnitAt(index)) {
       case BRACE_BEGIN:
         if (afterEscape) {
           afterEscape = false;
         } else {
           braceLevel++;
         }
         break;
@@ skipping 48 matching lines @@
 // Recognition of line blocks, insertion of block hash into \LMHash{}.
 
 final latexArgumentRE = new RegExp(r"\{.*\}");
 
 cleanupLine(line) => cutRegexp(line, commentRE, startOffset: 1).trimRight();
 
 /// Returns concatenation of all lines from [startIndex] in [lines] until
 /// a hash block terminator is encountered or [nextIndex] reached (if so,
 /// the line lines[nextIndex] itself is not included); each line is cleaned
 /// up using [cleanupLine], and " " is inserted between the lines gathered.
-gatherLines(lines, startIndex, nextIndex) =>
-    lines.getRange(startIndex, nextIndex)
-      .takeWhile(isntHashBlockTerminator)
-      .map(cleanupLine)
-      .join(" ");
+gatherLines(lines, startIndex, nextIndex) => lines
+    .getRange(startIndex, nextIndex)
+    .takeWhile(isntHashBlockTerminator)
+    .map(cleanupLine)
+    .join(" ");
 
 /// Computes the hash value for the line block starting at [startIndex]
 /// in [lines], stopping just before [nextIndex].  SIDE EFFECT:
 /// Outputs the simplified text and its hash value to [listSink].
 computeHashValue(lines, startIndex, nextIndex, listSink) {
   final gatheredLine = gatherLines(lines, startIndex, nextIndex);
   final simplifiedLine = simplifyLine(gatheredLine);
   listSink.write("  % $simplifiedLine\n");
   var digest = sha1.convert(encodeUtf8(simplifiedLine));
   return digest.bytes;
 }
 
 computeHashString(lines, startIndex, nextIndex, listSink) =>
-    hex.encode(computeHashValue(lines,
-                                            startIndex,
-                                            nextIndex,
-                                            listSink));
+    hex.encode(computeHashValue(lines, startIndex, nextIndex, listSink));
 
 /// Computes and adds hashes to \LMHash{} lines in [lines] (which
 /// must be on the line numbers specified in [hashEvents]), and emits
 /// sectioning markers and hash values to [listSink], along with
 /// "comments" containing the simplified text (using the format
 /// '  % <text>', where the text is one, long line, for easy grepping
 /// etc.).
 addHashMarks(lines, hashEvents, listSink) {
   for (var hashEvent in hashEvents) {
     if (hashEvent is HashMarkerEvent) {
       var start = hashEvent.startLineNumber;
       var end = hashEvent.endLineNumber;
       final hashValue = computeHashString(lines, start + 1, end, listSink);
       lines[start] =
           lines[start].replaceAll(latexArgumentRE, "{" + hashValue + "}");
       listSink.write("  $hashValue\n");
     } else if (hashEvent is HashLabelEvent) {
       listSink.write("${hashEvent.labelText}\n");
     }
   }
 }
 
 /// Transforms LaTeX input to LaTeX output plus hash value list file.
-main ([args]) {
+main([args]) {
   if (args.length != 3) {
     print("Usage: addlatexhash.dart <input-file> <output-file> <list-file>");
     throw "Received ${args.length} arguments, expected three";
   }
 
   // Get LaTeX source.
   var inputFile = new File(args[0]);
   assert(inputFile.existsSync());
   var lines = inputFile.readAsLinesSync();
 
@@ skipping 25 matching lines @@
   normalizedLines = multilineNormalize(normalizedLines);
 
   // Insert hash values.
   var hashEvents = findHashEvents(normalizedLines);
   addHashMarks(normalizedLines, hashEvents, listSink);
 
   // Produce/finalize output.
   outputFile.writeAsStringSync(normalizedLines.join());
   listSink.close();
 }