1// Copyright 2006-2008 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#ifndef V8_STRING_STREAM_H_
29#define V8_STRING_STREAM_H_
30
31namespace v8 {
32namespace internal {
33
34
35class StringAllocator {
36 public:
37  virtual ~StringAllocator() {}
38  // Allocate a number of bytes.
39  virtual char* allocate(unsigned bytes) = 0;
40  // Allocate a larger number of bytes and copy the old buffer to the new one.
41  // bytes is an input and output parameter passing the old size of the buffer
42  // and returning the new size.  If allocation fails then we return the old
43  // buffer and do not increase the size.
44  virtual char* grow(unsigned* bytes) = 0;
45};
46
47
48// Normal allocator uses new[] and delete[].
49class HeapStringAllocator: public StringAllocator {
50 public:
51  ~HeapStringAllocator() { DeleteArray(space_); }
52  char* allocate(unsigned bytes);
53  char* grow(unsigned* bytes);
54 private:
55  char* space_;
56};
57
58
59// Allocator for use when no new c++ heap allocation is allowed.
60// Given a preallocated buffer up front and does no allocation while
61// building message.
62class NoAllocationStringAllocator: public StringAllocator {
63 public:
64  NoAllocationStringAllocator(char* memory, unsigned size);
65  char* allocate(unsigned bytes) { return space_; }
66  char* grow(unsigned* bytes);
67 private:
68  unsigned size_;
69  char* space_;
70};
71
72
73class FmtElm {
74 public:
75  FmtElm(int value) : type_(INT) {  // NOLINT
76    data_.u_int_ = value;
77  }
78  explicit FmtElm(double value) : type_(DOUBLE) {
79    data_.u_double_ = value;
80  }
81  FmtElm(const char* value) : type_(C_STR) {  // NOLINT
82    data_.u_c_str_ = value;
83  }
84  FmtElm(const Vector<const uc16>& value) : type_(LC_STR) {  // NOLINT
85    data_.u_lc_str_ = &value;
86  }
87  FmtElm(Object* value) : type_(OBJ) {  // NOLINT
88    data_.u_obj_ = value;
89  }
90  FmtElm(Handle<Object> value) : type_(HANDLE) {  // NOLINT
91    data_.u_handle_ = value.location();
92  }
93  FmtElm(void* value) : type_(POINTER) {  // NOLINT
94    data_.u_pointer_ = value;
95  }
96
97 private:
98  friend class StringStream;
99  enum Type { INT, DOUBLE, C_STR, LC_STR, OBJ, HANDLE, POINTER };
100  Type type_;
101  union {
102    int u_int_;
103    double u_double_;
104    const char* u_c_str_;
105    const Vector<const uc16>* u_lc_str_;
106    Object* u_obj_;
107    Object** u_handle_;
108    void* u_pointer_;
109  } data_;
110};
111
112
113class StringStream {
114 public:
115  explicit StringStream(StringAllocator* allocator):
116    allocator_(allocator),
117    capacity_(kInitialCapacity),
118    length_(0),
119    buffer_(allocator_->allocate(kInitialCapacity)) {
120    buffer_[0] = 0;
121  }
122
123  ~StringStream() {
124  }
125
126  bool Put(char c);
127  bool Put(String* str);
128  bool Put(String* str, int start, int end);
129  void Add(Vector<const char> format, Vector<FmtElm> elms);
130  void Add(const char* format);
131  void Add(Vector<const char> format);
132  void Add(const char* format, FmtElm arg0);
133  void Add(const char* format, FmtElm arg0, FmtElm arg1);
134  void Add(const char* format, FmtElm arg0, FmtElm arg1, FmtElm arg2);
135  void Add(const char* format,
136           FmtElm arg0,
137           FmtElm arg1,
138           FmtElm arg2,
139           FmtElm arg3);
140  void Add(const char* format,
141           FmtElm arg0,
142           FmtElm arg1,
143           FmtElm arg2,
144           FmtElm arg3,
145           FmtElm arg4);
146
147  // Getting the message out.
148  void OutputToFile(FILE* out);
149  void OutputToStdOut() { OutputToFile(stdout); }
150  void Log();
151  Handle<String> ToString();
152  SmartArrayPointer<const char> ToCString() const;
153  int length() const { return length_; }
154
155  // Object printing support.
156  void PrintName(Object* o);
157  void PrintFixedArray(FixedArray* array, unsigned int limit);
158  void PrintByteArray(ByteArray* ba);
159  void PrintUsingMap(JSObject* js_object);
160  void PrintPrototype(JSFunction* fun, Object* receiver);
161  void PrintSecurityTokenIfChanged(Object* function);
162  // NOTE: Returns the code in the output parameter.
163  void PrintFunction(Object* function, Object* receiver, Code** code);
164
165  // Reset the stream.
166  void Reset() {
167    length_ = 0;
168    buffer_[0] = 0;
169  }
170
171  // Mentioned object cache support.
172  void PrintMentionedObjectCache();
173  static void ClearMentionedObjectCache();
174#ifdef DEBUG
175  static bool IsMentionedObjectCacheClear();
176#endif
177
178
179  static const int kInitialCapacity = 16;
180
181 private:
182  void PrintObject(Object* obj);
183
184  StringAllocator* allocator_;
185  unsigned capacity_;
186  unsigned length_;  // does not include terminating 0-character
187  char* buffer_;
188
189  bool full() const { return (capacity_ - length_) == 1; }
190  int space() const { return capacity_ - length_; }
191
192  DISALLOW_IMPLICIT_CONSTRUCTORS(StringStream);
193};
194
195
196// Utility class to print a list of items to a stream, divided by a separator.
197class SimpleListPrinter {
198 public:
199  explicit SimpleListPrinter(StringStream* stream, char separator = ',') {
200    separator_ = separator;
201    stream_ = stream;
202    first_ = true;
203  }
204
205  void Add(const char* str) {
206    if (first_) {
207      first_ = false;
208    } else {
209      stream_->Put(separator_);
210    }
211    stream_->Add(str);
212  }
213
214 private:
215  bool first_;
216  char separator_;
217  StringStream* stream_;
218};
219
220
221} }  // namespace v8::internal
222
223#endif  // V8_STRING_STREAM_H_
224