v8  3.11.10(node0.8.26)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
test-fixed-dtoa.cc
Go to the documentation of this file.
1 // Copyright 2010 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 #include <stdlib.h>
29 
30 #include "v8.h"
31 
32 #include "platform.h"
33 #include "cctest.h"
34 #include "double.h"
35 #include "fixed-dtoa.h"
36 #include "gay-fixed.h"
37 
38 using namespace v8::internal;
39 
40 static const int kBufferSize = 500;
41 
42 TEST(FastFixedVariousDoubles) {
43  char buffer_container[kBufferSize];
44  Vector<char> buffer(buffer_container, kBufferSize);
45  int length;
46  int point;
47 
48  CHECK(FastFixedDtoa(1.0, 1, buffer, &length, &point));
49  CHECK_EQ("1", buffer.start());
50  CHECK_EQ(1, point);
51 
52  CHECK(FastFixedDtoa(1.0, 15, buffer, &length, &point));
53  CHECK_EQ("1", buffer.start());
54  CHECK_EQ(1, point);
55 
56  CHECK(FastFixedDtoa(1.0, 0, buffer, &length, &point));
57  CHECK_EQ("1", buffer.start());
58  CHECK_EQ(1, point);
59 
60  CHECK(FastFixedDtoa(0xFFFFFFFF, 5, buffer, &length, &point));
61  CHECK_EQ("4294967295", buffer.start());
62  CHECK_EQ(10, point);
63 
64  CHECK(FastFixedDtoa(4294967296.0, 5, buffer, &length, &point));
65  CHECK_EQ("4294967296", buffer.start());
66  CHECK_EQ(10, point);
67 
68  CHECK(FastFixedDtoa(1e21, 5, buffer, &length, &point));
69  CHECK_EQ("1", buffer.start());
70  // CHECK_EQ(22, point);
71  CHECK_EQ(22, point);
72 
73  CHECK(FastFixedDtoa(999999999999999868928.00, 2, buffer, &length, &point));
74  CHECK_EQ("999999999999999868928", buffer.start());
75  CHECK_EQ(21, point);
76 
77  CHECK(FastFixedDtoa(6.9999999999999989514240000e+21, 5, buffer,
78  &length, &point));
79  CHECK_EQ("6999999999999998951424", buffer.start());
80  CHECK_EQ(22, point);
81 
82  CHECK(FastFixedDtoa(1.5, 5, buffer, &length, &point));
83  CHECK_EQ("15", buffer.start());
84  CHECK_EQ(1, point);
85 
86  CHECK(FastFixedDtoa(1.55, 5, buffer, &length, &point));
87  CHECK_EQ("155", buffer.start());
88  CHECK_EQ(1, point);
89 
90  CHECK(FastFixedDtoa(1.55, 1, buffer, &length, &point));
91  CHECK_EQ("16", buffer.start());
92  CHECK_EQ(1, point);
93 
94  CHECK(FastFixedDtoa(1.00000001, 15, buffer, &length, &point));
95  CHECK_EQ("100000001", buffer.start());
96  CHECK_EQ(1, point);
97 
98  CHECK(FastFixedDtoa(0.1, 10, buffer, &length, &point));
99  CHECK_EQ("1", buffer.start());
100  CHECK_EQ(0, point);
101 
102  CHECK(FastFixedDtoa(0.01, 10, buffer, &length, &point));
103  CHECK_EQ("1", buffer.start());
104  CHECK_EQ(-1, point);
105 
106  CHECK(FastFixedDtoa(0.001, 10, buffer, &length, &point));
107  CHECK_EQ("1", buffer.start());
108  CHECK_EQ(-2, point);
109 
110  CHECK(FastFixedDtoa(0.0001, 10, buffer, &length, &point));
111  CHECK_EQ("1", buffer.start());
112  CHECK_EQ(-3, point);
113 
114  CHECK(FastFixedDtoa(0.00001, 10, buffer, &length, &point));
115  CHECK_EQ("1", buffer.start());
116  CHECK_EQ(-4, point);
117 
118  CHECK(FastFixedDtoa(0.000001, 10, buffer, &length, &point));
119  CHECK_EQ("1", buffer.start());
120  CHECK_EQ(-5, point);
121 
122  CHECK(FastFixedDtoa(0.0000001, 10, buffer, &length, &point));
123  CHECK_EQ("1", buffer.start());
124  CHECK_EQ(-6, point);
125 
126  CHECK(FastFixedDtoa(0.00000001, 10, buffer, &length, &point));
127  CHECK_EQ("1", buffer.start());
128  CHECK_EQ(-7, point);
129 
130  CHECK(FastFixedDtoa(0.000000001, 10, buffer, &length, &point));
131  CHECK_EQ("1", buffer.start());
132  CHECK_EQ(-8, point);
133 
134  CHECK(FastFixedDtoa(0.0000000001, 15, buffer, &length, &point));
135  CHECK_EQ("1", buffer.start());
136  CHECK_EQ(-9, point);
137 
138  CHECK(FastFixedDtoa(0.00000000001, 15, buffer, &length, &point));
139  CHECK_EQ("1", buffer.start());
140  CHECK_EQ(-10, point);
141 
142  CHECK(FastFixedDtoa(0.000000000001, 15, buffer, &length, &point));
143  CHECK_EQ("1", buffer.start());
144  CHECK_EQ(-11, point);
145 
146  CHECK(FastFixedDtoa(0.0000000000001, 15, buffer, &length, &point));
147  CHECK_EQ("1", buffer.start());
148  CHECK_EQ(-12, point);
149 
150  CHECK(FastFixedDtoa(0.00000000000001, 15, buffer, &length, &point));
151  CHECK_EQ("1", buffer.start());
152  CHECK_EQ(-13, point);
153 
154  CHECK(FastFixedDtoa(0.000000000000001, 20, buffer, &length, &point));
155  CHECK_EQ("1", buffer.start());
156  CHECK_EQ(-14, point);
157 
158  CHECK(FastFixedDtoa(0.0000000000000001, 20, buffer, &length, &point));
159  CHECK_EQ("1", buffer.start());
160  CHECK_EQ(-15, point);
161 
162  CHECK(FastFixedDtoa(0.00000000000000001, 20, buffer, &length, &point));
163  CHECK_EQ("1", buffer.start());
164  CHECK_EQ(-16, point);
165 
166  CHECK(FastFixedDtoa(0.000000000000000001, 20, buffer, &length, &point));
167  CHECK_EQ("1", buffer.start());
168  CHECK_EQ(-17, point);
169 
170  CHECK(FastFixedDtoa(0.0000000000000000001, 20, buffer, &length, &point));
171  CHECK_EQ("1", buffer.start());
172  CHECK_EQ(-18, point);
173 
174  CHECK(FastFixedDtoa(0.00000000000000000001, 20, buffer, &length, &point));
175  CHECK_EQ("1", buffer.start());
176  CHECK_EQ(-19, point);
177 
178  CHECK(FastFixedDtoa(0.10000000004, 10, buffer, &length, &point));
179  CHECK_EQ("1", buffer.start());
180  CHECK_EQ(0, point);
181 
182  CHECK(FastFixedDtoa(0.01000000004, 10, buffer, &length, &point));
183  CHECK_EQ("1", buffer.start());
184  CHECK_EQ(-1, point);
185 
186  CHECK(FastFixedDtoa(0.00100000004, 10, buffer, &length, &point));
187  CHECK_EQ("1", buffer.start());
188  CHECK_EQ(-2, point);
189 
190  CHECK(FastFixedDtoa(0.00010000004, 10, buffer, &length, &point));
191  CHECK_EQ("1", buffer.start());
192  CHECK_EQ(-3, point);
193 
194  CHECK(FastFixedDtoa(0.00001000004, 10, buffer, &length, &point));
195  CHECK_EQ("1", buffer.start());
196  CHECK_EQ(-4, point);
197 
198  CHECK(FastFixedDtoa(0.00000100004, 10, buffer, &length, &point));
199  CHECK_EQ("1", buffer.start());
200  CHECK_EQ(-5, point);
201 
202  CHECK(FastFixedDtoa(0.00000010004, 10, buffer, &length, &point));
203  CHECK_EQ("1", buffer.start());
204  CHECK_EQ(-6, point);
205 
206  CHECK(FastFixedDtoa(0.00000001004, 10, buffer, &length, &point));
207  CHECK_EQ("1", buffer.start());
208  CHECK_EQ(-7, point);
209 
210  CHECK(FastFixedDtoa(0.00000000104, 10, buffer, &length, &point));
211  CHECK_EQ("1", buffer.start());
212  CHECK_EQ(-8, point);
213 
214  CHECK(FastFixedDtoa(0.0000000001000004, 15, buffer, &length, &point));
215  CHECK_EQ("1", buffer.start());
216  CHECK_EQ(-9, point);
217 
218  CHECK(FastFixedDtoa(0.0000000000100004, 15, buffer, &length, &point));
219  CHECK_EQ("1", buffer.start());
220  CHECK_EQ(-10, point);
221 
222  CHECK(FastFixedDtoa(0.0000000000010004, 15, buffer, &length, &point));
223  CHECK_EQ("1", buffer.start());
224  CHECK_EQ(-11, point);
225 
226  CHECK(FastFixedDtoa(0.0000000000001004, 15, buffer, &length, &point));
227  CHECK_EQ("1", buffer.start());
228  CHECK_EQ(-12, point);
229 
230  CHECK(FastFixedDtoa(0.0000000000000104, 15, buffer, &length, &point));
231  CHECK_EQ("1", buffer.start());
232  CHECK_EQ(-13, point);
233 
234  CHECK(FastFixedDtoa(0.000000000000001000004, 20, buffer, &length, &point));
235  CHECK_EQ("1", buffer.start());
236  CHECK_EQ(-14, point);
237 
238  CHECK(FastFixedDtoa(0.000000000000000100004, 20, buffer, &length, &point));
239  CHECK_EQ("1", buffer.start());
240  CHECK_EQ(-15, point);
241 
242  CHECK(FastFixedDtoa(0.000000000000000010004, 20, buffer, &length, &point));
243  CHECK_EQ("1", buffer.start());
244  CHECK_EQ(-16, point);
245 
246  CHECK(FastFixedDtoa(0.000000000000000001004, 20, buffer, &length, &point));
247  CHECK_EQ("1", buffer.start());
248  CHECK_EQ(-17, point);
249 
250  CHECK(FastFixedDtoa(0.000000000000000000104, 20, buffer, &length, &point));
251  CHECK_EQ("1", buffer.start());
252  CHECK_EQ(-18, point);
253 
254  CHECK(FastFixedDtoa(0.000000000000000000014, 20, buffer, &length, &point));
255  CHECK_EQ("1", buffer.start());
256  CHECK_EQ(-19, point);
257 
258  CHECK(FastFixedDtoa(0.10000000006, 10, buffer, &length, &point));
259  CHECK_EQ("1000000001", buffer.start());
260  CHECK_EQ(0, point);
261 
262  CHECK(FastFixedDtoa(0.01000000006, 10, buffer, &length, &point));
263  CHECK_EQ("100000001", buffer.start());
264  CHECK_EQ(-1, point);
265 
266  CHECK(FastFixedDtoa(0.00100000006, 10, buffer, &length, &point));
267  CHECK_EQ("10000001", buffer.start());
268  CHECK_EQ(-2, point);
269 
270  CHECK(FastFixedDtoa(0.00010000006, 10, buffer, &length, &point));
271  CHECK_EQ("1000001", buffer.start());
272  CHECK_EQ(-3, point);
273 
274  CHECK(FastFixedDtoa(0.00001000006, 10, buffer, &length, &point));
275  CHECK_EQ("100001", buffer.start());
276  CHECK_EQ(-4, point);
277 
278  CHECK(FastFixedDtoa(0.00000100006, 10, buffer, &length, &point));
279  CHECK_EQ("10001", buffer.start());
280  CHECK_EQ(-5, point);
281 
282  CHECK(FastFixedDtoa(0.00000010006, 10, buffer, &length, &point));
283  CHECK_EQ("1001", buffer.start());
284  CHECK_EQ(-6, point);
285 
286  CHECK(FastFixedDtoa(0.00000001006, 10, buffer, &length, &point));
287  CHECK_EQ("101", buffer.start());
288  CHECK_EQ(-7, point);
289 
290  CHECK(FastFixedDtoa(0.00000000106, 10, buffer, &length, &point));
291  CHECK_EQ("11", buffer.start());
292  CHECK_EQ(-8, point);
293 
294  CHECK(FastFixedDtoa(0.0000000001000006, 15, buffer, &length, &point));
295  CHECK_EQ("100001", buffer.start());
296  CHECK_EQ(-9, point);
297 
298  CHECK(FastFixedDtoa(0.0000000000100006, 15, buffer, &length, &point));
299  CHECK_EQ("10001", buffer.start());
300  CHECK_EQ(-10, point);
301 
302  CHECK(FastFixedDtoa(0.0000000000010006, 15, buffer, &length, &point));
303  CHECK_EQ("1001", buffer.start());
304  CHECK_EQ(-11, point);
305 
306  CHECK(FastFixedDtoa(0.0000000000001006, 15, buffer, &length, &point));
307  CHECK_EQ("101", buffer.start());
308  CHECK_EQ(-12, point);
309 
310  CHECK(FastFixedDtoa(0.0000000000000106, 15, buffer, &length, &point));
311  CHECK_EQ("11", buffer.start());
312  CHECK_EQ(-13, point);
313 
314  CHECK(FastFixedDtoa(0.000000000000001000006, 20, buffer, &length, &point));
315  CHECK_EQ("100001", buffer.start());
316  CHECK_EQ(-14, point);
317 
318  CHECK(FastFixedDtoa(0.000000000000000100006, 20, buffer, &length, &point));
319  CHECK_EQ("10001", buffer.start());
320  CHECK_EQ(-15, point);
321 
322  CHECK(FastFixedDtoa(0.000000000000000010006, 20, buffer, &length, &point));
323  CHECK_EQ("1001", buffer.start());
324  CHECK_EQ(-16, point);
325 
326  CHECK(FastFixedDtoa(0.000000000000000001006, 20, buffer, &length, &point));
327  CHECK_EQ("101", buffer.start());
328  CHECK_EQ(-17, point);
329 
330  CHECK(FastFixedDtoa(0.000000000000000000106, 20, buffer, &length, &point));
331  CHECK_EQ("11", buffer.start());
332  CHECK_EQ(-18, point);
333 
334  CHECK(FastFixedDtoa(0.000000000000000000016, 20, buffer, &length, &point));
335  CHECK_EQ("2", buffer.start());
336  CHECK_EQ(-19, point);
337 
338  CHECK(FastFixedDtoa(0.6, 0, buffer, &length, &point));
339  CHECK_EQ("1", buffer.start());
340  CHECK_EQ(1, point);
341 
342  CHECK(FastFixedDtoa(0.96, 1, buffer, &length, &point));
343  CHECK_EQ("1", buffer.start());
344  CHECK_EQ(1, point);
345 
346  CHECK(FastFixedDtoa(0.996, 2, buffer, &length, &point));
347  CHECK_EQ("1", buffer.start());
348  CHECK_EQ(1, point);
349 
350  CHECK(FastFixedDtoa(0.9996, 3, buffer, &length, &point));
351  CHECK_EQ("1", buffer.start());
352  CHECK_EQ(1, point);
353 
354  CHECK(FastFixedDtoa(0.99996, 4, buffer, &length, &point));
355  CHECK_EQ("1", buffer.start());
356  CHECK_EQ(1, point);
357 
358  CHECK(FastFixedDtoa(0.999996, 5, buffer, &length, &point));
359  CHECK_EQ("1", buffer.start());
360  CHECK_EQ(1, point);
361 
362  CHECK(FastFixedDtoa(0.9999996, 6, buffer, &length, &point));
363  CHECK_EQ("1", buffer.start());
364  CHECK_EQ(1, point);
365 
366  CHECK(FastFixedDtoa(0.99999996, 7, buffer, &length, &point));
367  CHECK_EQ("1", buffer.start());
368  CHECK_EQ(1, point);
369 
370  CHECK(FastFixedDtoa(0.999999996, 8, buffer, &length, &point));
371  CHECK_EQ("1", buffer.start());
372  CHECK_EQ(1, point);
373 
374  CHECK(FastFixedDtoa(0.9999999996, 9, buffer, &length, &point));
375  CHECK_EQ("1", buffer.start());
376  CHECK_EQ(1, point);
377 
378  CHECK(FastFixedDtoa(0.99999999996, 10, buffer, &length, &point));
379  CHECK_EQ("1", buffer.start());
380  CHECK_EQ(1, point);
381 
382  CHECK(FastFixedDtoa(0.999999999996, 11, buffer, &length, &point));
383  CHECK_EQ("1", buffer.start());
384  CHECK_EQ(1, point);
385 
386  CHECK(FastFixedDtoa(0.9999999999996, 12, buffer, &length, &point));
387  CHECK_EQ("1", buffer.start());
388  CHECK_EQ(1, point);
389 
390  CHECK(FastFixedDtoa(0.99999999999996, 13, buffer, &length, &point));
391  CHECK_EQ("1", buffer.start());
392  CHECK_EQ(1, point);
393 
394  CHECK(FastFixedDtoa(0.999999999999996, 14, buffer, &length, &point));
395  CHECK_EQ("1", buffer.start());
396  CHECK_EQ(1, point);
397 
398  CHECK(FastFixedDtoa(0.9999999999999996, 15, buffer, &length, &point));
399  CHECK_EQ("1", buffer.start());
400  CHECK_EQ(1, point);
401 
402  CHECK(FastFixedDtoa(0.00999999999999996, 16, buffer, &length, &point));
403  CHECK_EQ("1", buffer.start());
404  CHECK_EQ(-1, point);
405 
406  CHECK(FastFixedDtoa(0.000999999999999996, 17, buffer, &length, &point));
407  CHECK_EQ("1", buffer.start());
408  CHECK_EQ(-2, point);
409 
410  CHECK(FastFixedDtoa(0.0000999999999999996, 18, buffer, &length, &point));
411  CHECK_EQ("1", buffer.start());
412  CHECK_EQ(-3, point);
413 
414  CHECK(FastFixedDtoa(0.00000999999999999996, 19, buffer, &length, &point));
415  CHECK_EQ("1", buffer.start());
416  CHECK_EQ(-4, point);
417 
418  CHECK(FastFixedDtoa(0.000000999999999999996, 20, buffer, &length, &point));
419  CHECK_EQ("1", buffer.start());
420  CHECK_EQ(-5, point);
421 
422  CHECK(FastFixedDtoa(323423.234234, 10, buffer, &length, &point));
423  CHECK_EQ("323423234234", buffer.start());
424  CHECK_EQ(6, point);
425 
426  CHECK(FastFixedDtoa(12345678.901234, 4, buffer, &length, &point));
427  CHECK_EQ("123456789012", buffer.start());
428  CHECK_EQ(8, point);
429 
430  CHECK(FastFixedDtoa(98765.432109, 5, buffer, &length, &point));
431  CHECK_EQ("9876543211", buffer.start());
432  CHECK_EQ(5, point);
433 
434  CHECK(FastFixedDtoa(42, 20, buffer, &length, &point));
435  CHECK_EQ("42", buffer.start());
436  CHECK_EQ(2, point);
437 
438  CHECK(FastFixedDtoa(0.5, 0, buffer, &length, &point));
439  CHECK_EQ("1", buffer.start());
440  CHECK_EQ(1, point);
441 
442  CHECK(FastFixedDtoa(1e-23, 10, buffer, &length, &point));
443  CHECK_EQ("", buffer.start());
444  CHECK_EQ(-10, point);
445 
446  CHECK(FastFixedDtoa(1e-123, 2, buffer, &length, &point));
447  CHECK_EQ("", buffer.start());
448  CHECK_EQ(-2, point);
449 
450  CHECK(FastFixedDtoa(1e-123, 0, buffer, &length, &point));
451  CHECK_EQ("", buffer.start());
452  CHECK_EQ(0, point);
453 
454  CHECK(FastFixedDtoa(1e-23, 20, buffer, &length, &point));
455  CHECK_EQ("", buffer.start());
456  CHECK_EQ(-20, point);
457 
458  CHECK(FastFixedDtoa(1e-21, 20, buffer, &length, &point));
459  CHECK_EQ("", buffer.start());
460  CHECK_EQ(-20, point);
461 
462  CHECK(FastFixedDtoa(1e-22, 20, buffer, &length, &point));
463  CHECK_EQ("", buffer.start());
464  CHECK_EQ(-20, point);
465 
466  CHECK(FastFixedDtoa(6e-21, 20, buffer, &length, &point));
467  CHECK_EQ("1", buffer.start());
468  CHECK_EQ(-19, point);
469 
470  CHECK(FastFixedDtoa(9.1193616301674545152000000e+19, 0,
471  buffer, &length, &point));
472  CHECK_EQ("91193616301674545152", buffer.start());
473  CHECK_EQ(20, point);
474 
475  CHECK(FastFixedDtoa(4.8184662102767651659096515e-04, 19,
476  buffer, &length, &point));
477  CHECK_EQ("4818466210276765", buffer.start());
478  CHECK_EQ(-3, point);
479 
480  CHECK(FastFixedDtoa(1.9023164229540652612705182e-23, 8,
481  buffer, &length, &point));
482  CHECK_EQ("", buffer.start());
483  CHECK_EQ(-8, point);
484 
485  CHECK(FastFixedDtoa(1000000000000000128.0, 0,
486  buffer, &length, &point));
487  CHECK_EQ("1000000000000000128", buffer.start());
488  CHECK_EQ(19, point);
489 }
490 
491 
492 TEST(FastFixedDtoaGayFixed) {
493  char buffer_container[kBufferSize];
494  Vector<char> buffer(buffer_container, kBufferSize);
495  bool status;
496  int length;
497  int point;
498 
499  Vector<const PrecomputedFixed> precomputed =
500  PrecomputedFixedRepresentations();
501  for (int i = 0; i < precomputed.length(); ++i) {
502  const PrecomputedFixed current_test = precomputed[i];
503  double v = current_test.v;
504  int number_digits = current_test.number_digits;
505  status = FastFixedDtoa(v, number_digits,
506  buffer, &length, &point);
507  CHECK(status);
508  CHECK_EQ(current_test.decimal_point, point);
509  CHECK_GE(number_digits, length - point);
510  CHECK_EQ(current_test.representation, buffer.start());
511  }
512 }
CHECK_EQ
#define CHECK_EQ(expected, value)
Definition: checks.h:219
v8::internal::PrecomputedFixedRepresentations
Vector< const PrecomputedFixed > PrecomputedFixedRepresentations()
Definition: gay-fixed.cc:100043
CHECK
#define CHECK(condition)
Definition: checks.h:56
CHECK_GE
#define CHECK_GE(a, b)
Definition: checks.h:228
v8::internal::Vector::start
T * start() const
Definition: utils.h:389
v8::internal::Vector::length
int length() const
Definition: utils.h:383
v8::internal::FastFixedDtoa
bool FastFixedDtoa(double v, int fractional_count, Vector< char > buffer, int *length, int *decimal_point)
Definition: fixed-dtoa.cc:312