src/string-stream.h

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