Handle escapes in string literals.

frog/leg/ssa/nodes.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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 1046 matching lines @@
     }
     return HType.UNKNOWN;
   }
 
   bool hasExpectedType() => builtinJsName != null;
 
   HInstruction fold() {
     if (name == 'length' && inputs[1].isLiteralString()) {
       // TODO(lrn): Account for escapes in string. Currently we count characters
       // in the uninterpreted (but unquoted) string.
-      QuotedString string = inputs[1].value;
-      int contentLength = string.contentEnd - string.contentStart;
-      return new HLiteral(contentLength, HType.INTEGER);
     }
     return this;
   }
 
   void prepareGvn() {
     if (builtinJsName == 'length') {
       assert(!hasSideEffects());
     } else {
       setAllSideEffects();
     }
@@ skipping 469 matching lines @@
   bool get isRaw() => (flags & RAW) != 0;
   String get quoteChar() => ((flags & SINGLE_QUOTED) != 0) ? "'" : '"';
 
   int get contentStart() =>
      hasLeftQuote ? (isRaw ? 1 : 0) + (isMultiLine ? 3 : 1) : 0;
   int get contentEnd() =>
      wrappedString.length - (hasRightQuote ? (isMultiLine ? 3 : 1) : 0);
 
   bool isEmpty() => contentStart == contentEnd;
 
+  static int hexValue(int hexDigit) {
+    // hexDigit is one of '0'..'9', 'A'..'F' and 'a'..'f'.
+    if (hexDigit <= 0x39) {
+      return hexDigit - 0x30;

[floitsch, 2012/01/12 12:30:28]

Don't use random constants. I would prefer not to do these optimizations before
we actually need them, but at the very least assert that you are right:
int nineCharCode = 0x39;
assert("9".charCodeAt(0) == nineCharCode);

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

Now uses $9, etc.

+    }
+    // Make letters lowercase.
+    hexDigit |= 0x20;
+    hexDigit -= 0x61 - 10;
+    assert(0 <= hexDigit && hexDigit <= 15);
+    return hexDigit;
+  }
+
+  /* Write the contents of the quoted string to a [StringBuffer] in

[floitsch, 2012/01/12 12:30:28]

/**

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

Done.

+   * a form that is valid as JavaScript string literal content.
+   * The string is assumed quoted by [quote] characters.
+   * This method doesn't try to make the shortest string, but rather
+   * to be as close to the original string as possible.
+   */
+  void writeEscaped(StringBuffer buffer, String quote) {
+    bool raw = this.isRaw;
+    int from = contentStart;
+    int end = contentEnd;
+    for (int i = from; i < end; i++) {
+      String character = wrappedString[i];
+      if (character == quote) {
+        // Insert backslash before unquoted quote character.
+        wrappedString.printSubstringOn(buffer, from, i);
+        buffer.add(@'\');
+        from = i;
+      } else if (character == @'\') {
+        if (raw) {
+          wrappedString.printSubstringOn(buffer, from, i);
+          buffer.add(@'\');

[floitsch, 2012/01/12 12:30:28]

Don't you need to update from?

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

I did. It's now completely rewritten.

+        } else {
+          character = wrappedString[++i];

[floitsch, 2012/01/12 12:30:28]

I find it easier to i++; first:
i++;
character = wrappedString[i];

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

In many cases I'd agree. In this, I actually read the entire thing as a simple
iteration through the wrappedString.
Anyway, it's gone now.

+          if (character == 'u') {
+            if (wrappedString[++i] == '{') {

[floitsch, 2012/01/12 12:30:28]

ditto

[floitsch, 2012/01/12 12:30:28]

Maybe move the \u{...} section into a (local/nested?) method.

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

Moved.

+              // In Dart, \u{x+} is a valid escape, but not in
+              // JS. Convert to a \uxxxx escape.
+              wrappedString.printSubstringOn(buffer, from, i);
+              int value = 0;
+              int hexDigit = wrappedString.charCodeAt(++i);

[floitsch, 2012/01/12 12:30:28]

ditto. (maybe also move i++ up, so that it is clear that '{' has been consumed)
use i++;

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

gone.

+              do {
+                value = value * 16 + hexValue(hexDigit);
+                hexDigit = wrappedString.charCodeAt(++i);

[floitsch, 2012/01/12 12:30:28]

use i++

+              } while (hexDigit !== 0x7d);  // until '}'.

[floitsch, 2012/01/12 12:30:28]

magic value.

+              // JavaScript only supports characters in the BMP.

[floitsch, 2012/01/12 12:30:28]

That's not true. It allows for the full UTF-16. We should probably generate a
surrogate pair.
At the very least add a TODO, but I would either implement it, or bailout.

+              if (value > 0xffff) value = 0xfffd;
+
+              for (int j = 12; j >= 0; j -= 4) {
+                int digit = (value >> j) & 0xf;
+                buffer.add("0123456789abcdef"[digit]);
+              }
+              from = i + 1;
+            }
+          } else if ('0' == character ||
+                     '1' == character ||
+                     '2' == character ||
+                     '3' == character ||
+                     '4' == character ||
+                     '5' == character ||
+                     '6' == character ||
+                     '7' == character) {
+            // In Dart "\[0-9]" are identity escapes. In JS,
+            // they start an octal escape, so we need to remove the '\'.
+            wrappedString.printSubstringOn(buffer, from, i - 1);
+            from = i;
+          }
+          // All other valid Dart escapes are also valid JS escapes
+          // with the same meaning, so we include them verbatim.

[floitsch, 2012/01/12 12:30:28]

I would still prefer to have them explicitly handled: one section dealing with
identical special escapes, and one where we can remove the '\' (identity
escapes). Otherwise we have to trust your comment...

[Lasse Reichstein Nielsen, 2012/01/16 13:30:23]

Done.

+        }
+      }
+    }
+    wrappedString.printSubstringOn(buffer, from, end);
+  }
+
   /**
     * Does a conservative test for equality between two quoted strings.
     * Returns true if the two definitly have the same string.
     * Returns false if the strings are different, or if it's not possible
     * to (quickly) determine whether they are equal.
     */
   bool definitlyEquals(QuotedString other) {
     return flags == other.flags && wrappedString == other.wrappedString;
   }
 
@@ skipping 424 matching lines @@
                    HInstruction first,
                    HInstruction second)
       : super(<HInstruction>[first, second]);
   toString() => operation;
   accept(HVisitor visitor) => visitor.visitLogicalOperator(this);
   HInstruction get left() => inputs[0];
   HInstruction get right() => inputs[1];
   HType computeType() => HType.BOOLEAN;
   bool hasExpectedType() => true;
 }