1 // Copyright 2014 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_STRING_STREAM_H_ 6 #define V8_STRING_STREAM_H_ 7 8 #include "src/handles.h" 9 10 namespace v8 { 11 namespace internal { 12 13 class StringAllocator { 14 public: ~StringAllocator()15 virtual ~StringAllocator() { } 16 // Allocate a number of bytes. 17 virtual char* allocate(unsigned bytes) = 0; 18 // Allocate a larger number of bytes and copy the old buffer to the new one. 19 // bytes is an input and output parameter passing the old size of the buffer 20 // and returning the new size. If allocation fails then we return the old 21 // buffer and do not increase the size. 22 virtual char* grow(unsigned* bytes) = 0; 23 }; 24 25 26 // Normal allocator uses new[] and delete[]. 27 class HeapStringAllocator FINAL : public StringAllocator { 28 public: ~HeapStringAllocator()29 ~HeapStringAllocator() { DeleteArray(space_); } 30 virtual char* allocate(unsigned bytes) OVERRIDE; 31 virtual char* grow(unsigned* bytes) OVERRIDE; 32 33 private: 34 char* space_; 35 }; 36 37 38 class FmtElm FINAL { 39 public: FmtElm(int value)40 FmtElm(int value) : type_(INT) { // NOLINT 41 data_.u_int_ = value; 42 } FmtElm(double value)43 explicit FmtElm(double value) : type_(DOUBLE) { 44 data_.u_double_ = value; 45 } FmtElm(const char * value)46 FmtElm(const char* value) : type_(C_STR) { // NOLINT 47 data_.u_c_str_ = value; 48 } FmtElm(const Vector<const uc16> & value)49 FmtElm(const Vector<const uc16>& value) : type_(LC_STR) { // NOLINT 50 data_.u_lc_str_ = &value; 51 } FmtElm(Object * value)52 FmtElm(Object* value) : type_(OBJ) { // NOLINT 53 data_.u_obj_ = value; 54 } FmtElm(Handle<Object> value)55 FmtElm(Handle<Object> value) : type_(HANDLE) { // NOLINT 56 data_.u_handle_ = value.location(); 57 } FmtElm(void * value)58 FmtElm(void* value) : type_(POINTER) { // NOLINT 59 data_.u_pointer_ = value; 60 } 61 62 private: 63 friend class StringStream; 64 enum Type { INT, DOUBLE, C_STR, LC_STR, OBJ, HANDLE, POINTER }; 65 Type type_; 66 union { 67 int u_int_; 68 double u_double_; 69 const char* u_c_str_; 70 const Vector<const uc16>* u_lc_str_; 71 Object* u_obj_; 72 Object** u_handle_; 73 void* u_pointer_; 74 } data_; 75 }; 76 77 78 class StringStream FINAL { 79 public: StringStream(StringAllocator * allocator)80 explicit StringStream(StringAllocator* allocator): 81 allocator_(allocator), 82 capacity_(kInitialCapacity), 83 length_(0), 84 buffer_(allocator_->allocate(kInitialCapacity)) { 85 buffer_[0] = 0; 86 } 87 88 bool Put(char c); 89 bool Put(String* str); 90 bool Put(String* str, int start, int end); 91 void Add(Vector<const char> format, Vector<FmtElm> elms); 92 void Add(const char* format); 93 void Add(Vector<const char> format); 94 void Add(const char* format, FmtElm arg0); 95 void Add(const char* format, FmtElm arg0, FmtElm arg1); 96 void Add(const char* format, FmtElm arg0, FmtElm arg1, FmtElm arg2); 97 void Add(const char* format, 98 FmtElm arg0, 99 FmtElm arg1, 100 FmtElm arg2, 101 FmtElm arg3); 102 void Add(const char* format, 103 FmtElm arg0, 104 FmtElm arg1, 105 FmtElm arg2, 106 FmtElm arg3, 107 FmtElm arg4); 108 109 // Getting the message out. 110 void OutputToFile(FILE* out); OutputToStdOut()111 void OutputToStdOut() { OutputToFile(stdout); } 112 void Log(Isolate* isolate); 113 Handle<String> ToString(Isolate* isolate); 114 SmartArrayPointer<const char> ToCString() const; length()115 int length() const { return length_; } 116 117 // Object printing support. 118 void PrintName(Object* o); 119 void PrintFixedArray(FixedArray* array, unsigned int limit); 120 void PrintByteArray(ByteArray* ba); 121 void PrintUsingMap(JSObject* js_object); 122 void PrintPrototype(JSFunction* fun, Object* receiver); 123 void PrintSecurityTokenIfChanged(Object* function); 124 // NOTE: Returns the code in the output parameter. 125 void PrintFunction(Object* function, Object* receiver, Code** code); 126 127 // Reset the stream. Reset()128 void Reset() { 129 length_ = 0; 130 buffer_[0] = 0; 131 } 132 133 // Mentioned object cache support. 134 void PrintMentionedObjectCache(Isolate* isolate); 135 static void ClearMentionedObjectCache(Isolate* isolate); 136 #ifdef DEBUG 137 static bool IsMentionedObjectCacheClear(Isolate* isolate); 138 #endif 139 140 static const int kInitialCapacity = 16; 141 142 private: 143 void PrintObject(Object* obj); 144 145 StringAllocator* allocator_; 146 unsigned capacity_; 147 unsigned length_; // does not include terminating 0-character 148 char* buffer_; 149 full()150 bool full() const { return (capacity_ - length_) == 1; } space()151 int space() const { return capacity_ - length_; } 152 153 DISALLOW_IMPLICIT_CONSTRUCTORS(StringStream); 154 }; 155 156 } } // namespace v8::internal 157 158 #endif // V8_STRING_STREAM_H_ 159