Home | History | Annotate | Download | only in src 
      1 // Copyright 2011 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 <stdarg.h>
     29 #include <limits.h>
     30 
     31 #include "v8.h"
     32 
     33 #include "conversions-inl.h"
     34 #include "v8conversions.h"
     35 #include "dtoa.h"
     36 #include "factory.h"
     37 #include "strtod.h"
     38 
     39 namespace v8 {
     40 namespace internal {
     41 
     42 namespace {
     43 
     44 // C++-style iterator adaptor for StringInputBuffer
     45 // (unlike C++ iterators the end-marker has different type).
     46 class StringInputBufferIterator {
     47  public:
     48   class EndMarker {};
     49 
     50   explicit StringInputBufferIterator(StringInputBuffer* buffer);
     51 
     52   int operator*() const;
     53   void operator++();
     54   bool operator==(EndMarker const&) const { return end_; }
     55   bool operator!=(EndMarker const& m) const { return !end_; }
     56 
     57  private:
     58   StringInputBuffer* const buffer_;
     59   int current_;
     60   bool end_;
     61 };
     62 
     63 
     64 StringInputBufferIterator::StringInputBufferIterator(
     65     StringInputBuffer* buffer) : buffer_(buffer) {
     66   ++(*this);
     67 }
     68 
     69 int StringInputBufferIterator::operator*() const {
     70   return current_;
     71 }
     72 
     73 
     74 void StringInputBufferIterator::operator++() {
     75   end_ = !buffer_->has_more();
     76   if (!end_) {
     77     current_ = buffer_->GetNext();
     78   }
     79 }
     80 }  // End anonymous namespace.
     81 
     82 
     83 double StringToDouble(UnicodeCache* unicode_cache,
     84                       String* str, int flags, double empty_string_val) {
     85   StringShape shape(str);
     86   if (shape.IsSequentialAscii()) {
     87     const char* begin = SeqAsciiString::cast(str)->GetChars();
     88     const char* end = begin + str->length();
     89     return InternalStringToDouble(unicode_cache, begin, end, flags,
     90                                   empty_string_val);
     91   } else if (shape.IsSequentialTwoByte()) {
     92     const uc16* begin = SeqTwoByteString::cast(str)->GetChars();
     93     const uc16* end = begin + str->length();
     94     return InternalStringToDouble(unicode_cache, begin, end, flags,
     95                                   empty_string_val);
     96   } else {
     97     StringInputBuffer buffer(str);
     98     return InternalStringToDouble(unicode_cache,
     99                                   StringInputBufferIterator(&buffer),
    100                                   StringInputBufferIterator::EndMarker(),
    101                                   flags,
    102                                   empty_string_val);
    103   }
    104 }
    105 
    106 
    107 double StringToInt(UnicodeCache* unicode_cache,
    108                    String* str,
    109                    int radix) {
    110   StringShape shape(str);
    111   if (shape.IsSequentialAscii()) {
    112     const char* begin = SeqAsciiString::cast(str)->GetChars();
    113     const char* end = begin + str->length();
    114     return InternalStringToInt(unicode_cache, begin, end, radix);
    115   } else if (shape.IsSequentialTwoByte()) {
    116     const uc16* begin = SeqTwoByteString::cast(str)->GetChars();
    117     const uc16* end = begin + str->length();
    118     return InternalStringToInt(unicode_cache, begin, end, radix);
    119   } else {
    120     StringInputBuffer buffer(str);
    121     return InternalStringToInt(unicode_cache,
    122                                StringInputBufferIterator(&buffer),
    123                                StringInputBufferIterator::EndMarker(),
    124                                radix);
    125   }
    126 }
    127 
    128 } }  // namespace v8::internal
    129