- Add a test case to test Source code generation of all the corelibs

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1822 matching lines @@
   RawArray* TokenObjects() const;
   void SetTokenObjects(const Array& value) const;
 
   RawExternalUint8Array* GetStream() const;
   void SetStream(const ExternalUint8Array& stream) const;
 
   RawString* GenerateSource() const;
   intptr_t ComputeSourcePosition(intptr_t tok_pos) const;
   intptr_t ComputeTokenPosition(intptr_t src_pos) const;
 
+  RawString* PrivateKey() const;
+
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTokenStream));
   }
 
   static RawTokenStream* New(intptr_t length);
   static RawTokenStream* New(const Scanner::GrowableTokenStream& tokens,
                              const String& private_key);
@@ skipping 34 matching lines @@
     const ExternalUint8Array& data_;
     ReadStream stream_;
     Array& token_objects_;
     Object& obj_;
     intptr_t cur_token_pos_;
     Token::Kind cur_token_kind_;
     intptr_t cur_token_obj_index_;
   };
 
  private:
-  RawString* PrivateKey() const;
   void SetPrivateKey(const String& value) const;
 
   static RawTokenStream* New();
   static void DataFinalizer(void *peer);
 
   HEAP_OBJECT_IMPLEMENTATION(TokenStream, Object);
   friend class Class;
 };
 
 
@@ skipping 1609 matching lines @@
   static void Copy(const String& dst,
                    intptr_t dst_offset,
                    const uint32_t* characters,
                    intptr_t len);
   static void Copy(const String& dst,
                    intptr_t dst_offset,
                    const String& src,
                    intptr_t src_offset,
                    intptr_t len);
 
-  static RawString* EscapeDoubleQuotes(const String& str);
+  static RawString* EscapeSpecialCharacters(const String& str, bool raw_str);
 
   static RawString* Concat(const String& str1,
                            const String& str2,
                            Heap::Space space = Heap::kNew);
   static RawString* ConcatAll(const Array& strings,
                               Heap::Space space = Heap::kNew);
 
   static RawString* SubString(const String& str,
                               intptr_t begin_index,
                               Heap::Space space = Heap::kNew);
@@ skipping 48 matching lines @@
 class OneByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kOneByteChar;
   }
 
-  RawOneByteString* EscapeDoubleQuotes() const;
+  RawOneByteString* EscapeSpecialCharacters(bool raw_str) const;
 
   bool EqualsIgnoringPrivateKey(const OneByteString& str) const;
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() { return OFFSET_OF(RawOneByteString, data_); }
 
   static intptr_t InstanceSize() {
@@ skipping 55 matching lines @@
 class TwoByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kTwoByteChar;
   }
 
-  RawTwoByteString* EscapeDoubleQuotes() const;
+  RawTwoByteString* EscapeSpecialCharacters(bool raw_str) const;
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTwoByteString) == OFFSET_OF(RawTwoByteString, data_));
     return 0;
   }
 
@@ skipping 41 matching lines @@
 class FourByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kFourByteChar;
   }
 
-  RawFourByteString* EscapeDoubleQuotes() const;
+  RawFourByteString* EscapeSpecialCharacters(bool raw_str) const;
 
   static const intptr_t kBytesPerElement = 4;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawFourByteString) == OFFSET_OF(RawFourByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
@@ skipping 1823 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_