src/3rdparty/v8/src/v8conversions.cc

   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