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 StringCharacterStream
     45 // (unlike C++ iterators the end-marker has different type).
     46 class StringCharacterStreamIterator {
     47  public:
     48   class EndMarker {};
     49 
     50   explicit StringCharacterStreamIterator(StringCharacterStream* stream);
     51 
     52   uint16_t 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   StringCharacterStream* const stream_;
     59   uint16_t current_;
     60   bool end_;
     61 };
     62 
     63 
     64 StringCharacterStreamIterator::StringCharacterStreamIterator(
     65     StringCharacterStream* stream) : stream_(stream) {
     66   ++(*this);
     67 }
     68 
     69 uint16_t StringCharacterStreamIterator::operator*() const {
     70   return current_;
     71 }
     72 
     73 
     74 void StringCharacterStreamIterator::operator++() {
     75   end_ = !stream_->HasMore();
     76   if (!end_) {
     77     current_ = stream_->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   // TODO(dcarney): Use a Visitor here.
     87   if (shape.IsSequentialAscii()) {
     88     const uint8_t* begin = SeqOneByteString::cast(str)->GetChars();
     89     const uint8_t* end = begin + str->length();
     90     return InternalStringToDouble(unicode_cache, begin, end, flags,
     91                                   empty_string_val);
     92   } else if (shape.IsSequentialTwoByte()) {
     93     const uc16* begin = SeqTwoByteString::cast(str)->GetChars();
     94     const uc16* end = begin + str->length();
     95     return InternalStringToDouble(unicode_cache, begin, end, flags,
     96                                   empty_string_val);
     97   } else {
     98     ConsStringIteratorOp op;
     99     StringCharacterStream stream(str, &op);
    100     return InternalStringToDouble(unicode_cache,
    101                                   StringCharacterStreamIterator(&stream),
    102                                   StringCharacterStreamIterator::EndMarker(),
    103                                   flags,
    104                                   empty_string_val);
    105   }
    106 }
    107 
    108 
    109 double StringToInt(UnicodeCache* unicode_cache,
    110                    String* str,
    111                    int radix) {
    112   StringShape shape(str);
    113   // TODO(dcarney): Use a Visitor here.
    114   if (shape.IsSequentialAscii()) {
    115     const uint8_t* begin = SeqOneByteString::cast(str)->GetChars();
    116     const uint8_t* end = begin + str->length();
    117     return InternalStringToInt(unicode_cache, begin, end, radix);
    118   } else if (shape.IsSequentialTwoByte()) {
    119     const uc16* begin = SeqTwoByteString::cast(str)->GetChars();
    120     const uc16* end = begin + str->length();
    121     return InternalStringToInt(unicode_cache, begin, end, radix);
    122   } else {
    123     ConsStringIteratorOp op;
    124     StringCharacterStream stream(str, &op);
    125     return InternalStringToInt(unicode_cache,
    126                                StringCharacterStreamIterator(&stream),
    127                                StringCharacterStreamIterator::EndMarker(),
    128                                radix);
    129   }
    130 }
    131 
    132 } }  // namespace v8::internal
    133