Create values for literal Strings.

frog/leg/compile_time_constants.dart

 // Copyright (c) 2012, 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.
 
 /**
  * The [CompileTimeConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 class CompileTimeConstantHandler extends CompilerTask {
@@ skipping 72 matching lines @@
    * other.
    */
   List<VariableElement> getStaticFinalFieldsForEmission() {
     return initialVariableValues.getKeys().filter((element) {
       return element.kind == ElementKind.FIELD
           && !element.isInstanceMember()
           && element.modifiers.isFinal();
     });
   }
 
-  String getJsCodeForVariable(VariableElement element) {
+  StringBuffer writeJsCodeForVariable(StringBuffer buffer,
+                                      VariableElement element) {
     var value = initialVariableValues[element];
-    if (value === null) return "(void 0)";
-    if (value is num) return "$value";
-    if (value === true) return "true";
-    if (value === false) return "false";
+    if (value === null) {
+      buffer.add("(void 0)");
+    } else if (value is num) {
+      buffer.add("$value");

[floitsch, 2012/02/14 16:08:02]

not your code, but could you please add parenthesis around negative numbers
(num.isNegative()).

[karlklose, 2012/02/15 10:37:30]

Done.

+    } else if (value === true) {
+      buffer.add("true");
+    } else if (value === false) {
+      buffer.add("false");
+    } else if (value is DartString) {
+      buffer.add("'");
+      writeEscapedString(value, buffer, (reason) {
+        compiler.cancel("failed to write escaped string: $value");
+      });
+      buffer.add("'");
+    } else {
+      // TODO(floitsch): support more values.
+      compiler.unimplemented("CompileTimeConstantHandler" +
+                             "writeJsCodeForVariable",
+                             node: element.parseNode(compiler));
+    }
+    return buffer;
+  }
 
-    // TODO(floitsch): support more values.
-    compiler.unimplemented("CompileTimeConstantHandler.getJsCodeForVariable",
-                           node: element.parseNode(compiler));
+  /**
+   * Write the contents of the quoted string to a [StringBuffer] in
+   * a form that is valid as JavaScript string literal content.
+   * The string is assumed quoted by single quote characters.
+   */
+  static void writeEscapedString(DartString string,
+                                 StringBuffer buffer,
+                                 void cancel(String reason)) {
+    Iterator<int> iterator = string.iterator();
+    while (iterator.hasNext()) {
+      int code = iterator.next();
+      if (code === $SQ) {
+        buffer.add(@"\'");
+      } else if (code === $LF) {
+        buffer.add(@'\n');
+      } else if (code === $CR) {
+        buffer.add(@'\r');
+      } else if (code === $LS) {
+        // This Unicode line terminator and $PS are invalid in JS string
+        // literals.
+        buffer.add(@'\u2028');
+      } else if (code === $PS) {
+        buffer.add(@'\u2029');
+      } else if (code === $BACKSLASH) {
+        buffer.add(@'\\');
+      } else {
+        if (code > 0xffff) {
+          cancel("Unhandled non-BMP character: U+" + code.toRadixString(16));
+        }
+        // TODO(lrn): Consider whether all codes above 0x7f really need to
+        // be escaped. We build a Dart string here, so it should be a literal
+        // stage that converts it to, e.g., UTF-8 for a JS interpreter.
+        if (code < 0x20) {
+          buffer.add(@'\x');
+          if (code < 0x10) buffer.add('0');
+          buffer.add(code.toRadixString(16));
+        } else if (code >= 0x80) {
+          if (code < 0x100) {
+            buffer.add(@'\x');
+            buffer.add(code.toRadixString(16));
+          } else {
+            buffer.add(@'\u');
+            if (code < 0x1000) {
+              buffer.add('0');
+            }
+            buffer.add(code.toRadixString(16));
+          }
+        } else {
+          buffer.add(new String.fromCharCodes(<int>[code]));
+        }
+      }
+    }
   }
 }
 
 class CompileTimeConstantEvaluator extends AbstractVisitor {
   final CompileTimeConstantHandler constantHandler;
   final TreeElements definitions;
   final Compiler compiler;
 
   CompileTimeConstantEvaluator(this.constantHandler,
                                this.definitions,
                                this.compiler);
 
   evaluate(Node node) {
     return node.accept(this);
   }
 
   visitNode(Node node) {
     compiler.unimplemented("CompileTimeConstantEvaluator", node: node);
   }
 
   visitLiteral(Literal literal) {
+    if (literal is LiteralString) {
+      assert(literal.asLiteralString().isValidated());
+      return literal.asLiteralString().dartString;
+    }
     return literal.value;
   }
 
   visitSend(Send send) {
     Element element = definitions[send];
     if (element !== null && element.kind == ElementKind.FIELD) {
       if (element.isInstanceMember() ||
           element.modifiers === null ||
           !element.modifiers.isFinal()) {
         error(element);
       }
       return constantHandler.compileVariable(element);
     }
     return super.visitSend(send);
   }
 
   error(Element element) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     List arguments = [element.name];
     Node node = element.parseNode(compiler);
     compiler.reportError(node, new CompileTimeConstantError(kind, arguments));
   }
 }