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