1// Copyright 2014 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_AST_VALUE_FACTORY_H_
29#define V8_AST_VALUE_FACTORY_H_
30
31#include "src/api.h"
32#include "src/hashmap.h"
33#include "src/utils.h"
34
35// AstString, AstValue and AstValueFactory are for storing strings and values
36// independent of the V8 heap and internalizing them later. During parsing,
37// AstStrings and AstValues are created and stored outside the heap, in
38// AstValueFactory. After parsing, the strings and values are internalized
39// (moved into the V8 heap).
40namespace v8 {
41namespace internal {
42
43class AstString : public ZoneObject {
44 public:
45  virtual ~AstString() {}
46
47  virtual int length() const = 0;
48  bool IsEmpty() const { return length() == 0; }
49
50  // Puts the string into the V8 heap.
51  virtual void Internalize(Isolate* isolate) = 0;
52
53  // This function can be called after internalizing.
54  V8_INLINE Handle<String> string() const {
55    DCHECK(!string_.is_null());
56    return string_;
57  }
58
59 protected:
60  // This is null until the string is internalized.
61  Handle<String> string_;
62};
63
64
65class AstRawString : public AstString {
66 public:
67  virtual int length() const OVERRIDE {
68    if (is_one_byte_)
69      return literal_bytes_.length();
70    return literal_bytes_.length() / 2;
71  }
72
73  virtual void Internalize(Isolate* isolate) OVERRIDE;
74
75  bool AsArrayIndex(uint32_t* index) const;
76
77  // The string is not null-terminated, use length() to find out the length.
78  const unsigned char* raw_data() const {
79    return literal_bytes_.start();
80  }
81  bool is_one_byte() const { return is_one_byte_; }
82  bool IsOneByteEqualTo(const char* data) const;
83  uint16_t FirstCharacter() const {
84    if (is_one_byte_)
85      return literal_bytes_[0];
86    const uint16_t* c =
87        reinterpret_cast<const uint16_t*>(literal_bytes_.start());
88    return *c;
89  }
90
91  // For storing AstRawStrings in a hash map.
92  uint32_t hash() const {
93    return hash_;
94  }
95  static bool Compare(void* a, void* b);
96
97 private:
98  friend class AstValueFactory;
99  friend class AstRawStringInternalizationKey;
100
101  AstRawString(bool is_one_byte, const Vector<const byte>& literal_bytes,
102            uint32_t hash)
103      : is_one_byte_(is_one_byte), literal_bytes_(literal_bytes), hash_(hash) {}
104
105  AstRawString()
106      : is_one_byte_(true),
107        hash_(0) {}
108
109  bool is_one_byte_;
110
111  // Points to memory owned by Zone.
112  Vector<const byte> literal_bytes_;
113  uint32_t hash_;
114};
115
116
117class AstConsString : public AstString {
118 public:
119  AstConsString(const AstString* left, const AstString* right)
120      : left_(left),
121        right_(right) {}
122
123  virtual int length() const OVERRIDE {
124    return left_->length() + right_->length();
125  }
126
127  virtual void Internalize(Isolate* isolate) OVERRIDE;
128
129 private:
130  friend class AstValueFactory;
131
132  const AstString* left_;
133  const AstString* right_;
134};
135
136
137// AstValue is either a string, a number, a string array, a boolean, or a
138// special value (null, undefined, the hole).
139class AstValue : public ZoneObject {
140 public:
141  bool IsString() const {
142    return type_ == STRING;
143  }
144
145  bool IsNumber() const {
146    return type_ == NUMBER || type_ == SMI;
147  }
148
149  const AstRawString* AsString() const {
150    if (type_ == STRING)
151      return string_;
152    UNREACHABLE();
153    return 0;
154  }
155
156  double AsNumber() const {
157    if (type_ == NUMBER)
158      return number_;
159    if (type_ == SMI)
160      return smi_;
161    UNREACHABLE();
162    return 0;
163  }
164
165  bool EqualsString(const AstRawString* string) const {
166    return type_ == STRING && string_ == string;
167  }
168
169  bool IsPropertyName() const;
170
171  bool BooleanValue() const;
172
173  void Internalize(Isolate* isolate);
174
175  // Can be called after Internalize has been called.
176  V8_INLINE Handle<Object> value() const {
177    if (type_ == STRING) {
178      return string_->string();
179    }
180    DCHECK(!value_.is_null());
181    return value_;
182  }
183
184 private:
185  friend class AstValueFactory;
186
187  enum Type {
188    STRING,
189    SYMBOL,
190    NUMBER,
191    SMI,
192    BOOLEAN,
193    STRING_ARRAY,
194    NULL_TYPE,
195    UNDEFINED,
196    THE_HOLE
197  };
198
199  explicit AstValue(const AstRawString* s) : type_(STRING) { string_ = s; }
200
201  explicit AstValue(const char* name) : type_(SYMBOL) { symbol_name_ = name; }
202
203  explicit AstValue(double n) : type_(NUMBER) { number_ = n; }
204
205  AstValue(Type t, int i) : type_(t) {
206    DCHECK(type_ == SMI);
207    smi_ = i;
208  }
209
210  explicit AstValue(bool b) : type_(BOOLEAN) { bool_ = b; }
211
212  explicit AstValue(ZoneList<const AstRawString*>* s) : type_(STRING_ARRAY) {
213    strings_ = s;
214  }
215
216  explicit AstValue(Type t) : type_(t) {
217    DCHECK(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
218  }
219
220  Type type_;
221
222  // Uninternalized value.
223  union {
224    const AstRawString* string_;
225    double number_;
226    int smi_;
227    bool bool_;
228    ZoneList<const AstRawString*>* strings_;
229    const char* symbol_name_;
230  };
231
232  // Internalized value (empty before internalized).
233  Handle<Object> value_;
234};
235
236
237// For generating string constants.
238#define STRING_CONSTANTS(F)                           \
239  F(anonymous_function, "(anonymous function)")       \
240  F(arguments, "arguments")                           \
241  F(constructor, "constructor")                       \
242  F(done, "done")                                     \
243  F(dot, ".")                                         \
244  F(dot_for, ".for")                                  \
245  F(dot_generator, ".generator")                      \
246  F(dot_generator_object, ".generator_object")        \
247  F(dot_iterator, ".iterator")                        \
248  F(dot_module, ".module")                            \
249  F(dot_result, ".result")                            \
250  F(empty, "")                                        \
251  F(eval, "eval")                                     \
252  F(initialize_const_global, "initializeConstGlobal") \
253  F(initialize_var_global, "initializeVarGlobal")     \
254  F(make_reference_error, "MakeReferenceError")       \
255  F(make_syntax_error, "MakeSyntaxError")             \
256  F(make_type_error, "MakeTypeError")                 \
257  F(module, "module")                                 \
258  F(native, "native")                                 \
259  F(next, "next")                                     \
260  F(proto, "__proto__")                               \
261  F(prototype, "prototype")                           \
262  F(this, "this")                                     \
263  F(use_asm, "use asm")                               \
264  F(use_strict, "use strict")                         \
265  F(value, "value")
266
267
268class AstValueFactory {
269 public:
270  AstValueFactory(Zone* zone, uint32_t hash_seed)
271      : string_table_(AstRawString::Compare),
272        zone_(zone),
273        isolate_(NULL),
274        hash_seed_(hash_seed) {
275#define F(name, str) \
276    name##_string_ = NULL;
277    STRING_CONSTANTS(F)
278#undef F
279  }
280
281  const AstRawString* GetOneByteString(Vector<const uint8_t> literal);
282  const AstRawString* GetOneByteString(const char* string) {
283    return GetOneByteString(Vector<const uint8_t>(
284        reinterpret_cast<const uint8_t*>(string), StrLength(string)));
285  }
286  const AstRawString* GetTwoByteString(Vector<const uint16_t> literal);
287  const AstRawString* GetString(Handle<String> literal);
288  const AstConsString* NewConsString(const AstString* left,
289                                     const AstString* right);
290
291  void Internalize(Isolate* isolate);
292  bool IsInternalized() {
293    return isolate_ != NULL;
294  }
295
296#define F(name, str) \
297  const AstRawString* name##_string() { \
298    if (name##_string_ == NULL) { \
299      const char* data = str; \
300      name##_string_ = GetOneByteString( \
301          Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), \
302                                static_cast<int>(strlen(data)))); \
303    } \
304    return name##_string_; \
305  }
306  STRING_CONSTANTS(F)
307#undef F
308
309  const AstValue* NewString(const AstRawString* string);
310  // A JavaScript symbol (ECMA-262 edition 6).
311  const AstValue* NewSymbol(const char* name);
312  const AstValue* NewNumber(double number);
313  const AstValue* NewSmi(int number);
314  const AstValue* NewBoolean(bool b);
315  const AstValue* NewStringList(ZoneList<const AstRawString*>* strings);
316  const AstValue* NewNull();
317  const AstValue* NewUndefined();
318  const AstValue* NewTheHole();
319
320 private:
321  const AstRawString* GetString(uint32_t hash, bool is_one_byte,
322                                Vector<const byte> literal_bytes);
323
324  // All strings are copied here, one after another (no NULLs inbetween).
325  HashMap string_table_;
326  // For keeping track of all AstValues and AstRawStrings we've created (so that
327  // they can be internalized later).
328  List<AstValue*> values_;
329  List<AstString*> strings_;
330  Zone* zone_;
331  Isolate* isolate_;
332
333  uint32_t hash_seed_;
334
335#define F(name, str) \
336  const AstRawString* name##_string_;
337  STRING_CONSTANTS(F)
338#undef F
339};
340
341} }  // namespace v8::internal
342
343#undef STRING_CONSTANTS
344
345#endif  // V8_AST_VALUE_FACTORY_H_
346