LCOV - app.info - js/src/v8-dtoa/utils.h

LCOV - code coverage report
| Current view: | directory - js/src/v8-dtoa - utils.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 24 | 24 | 100.0 %
| Date: | 2012-04-07 | Functions: | 11 | 10 | 90.9 %

           1                 : // Copyright 2006-2008 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_UTILS_H_
          29                 : #define V8_UTILS_H_
          30                 :
          31                 : #include <stdlib.h>
          32                 : #include <string.h>
          33                 :
          34                 : namespace v8 {
          35                 : namespace internal {
          36                 :
          37                 : // ----------------------------------------------------------------------------
          38                 : // General helper functions
          39                 :
          40          307541 : inline int StrLength(const char* string) {
          41          307541 :   size_t length = strlen(string);
          42          307541 :   ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
          43          307541 :   return static_cast<int>(length);
          44                 : }
          45                 :
          46                 : // ----------------------------------------------------------------------------
          47                 : // Miscellaneous
          48                 :
          49                 : template <typename T>
          50                 : class Vector {
          51                 :  public:
          52                 :   Vector() : start_(NULL), length_(0) {}
          53          448001 :   Vector(T* data, int length) : start_(data), length_(length) {
          54          448001 :     ASSERT(length == 0 || (length > 0 && data != NULL));
          55          448001 :   }
          56                 :
          57                 :   // Returns the length of the vector.
          58          985813 :   int length() const { return length_; }
          59                 :
          60                 :   // Returns the pointer to the start of the data in the vector.
          61          469988 :   T* start() const { return start_; }
          62                 :
          63                 :   // Access individual vector elements - checks bounds in debug mode.
          64         3803412 :   T& operator[](int index) const {
          65         3803412 :     ASSERT(0 <= index && index < length_);
          66         3803412 :     return start_[index];
          67                 :   }
          68                 :
          69                 :   inline Vector<T> operator+(int offset) {
          70                 :     ASSERT(offset < length_);
          71                 :     return Vector<T>(start_ + offset, length_ - offset);
          72                 :   }
          73                 :
          74                 :  private:
          75                 :   T* start_;
          76                 :   int length_;
          77                 : };
          78                 :
          79                 :
          80                 : // Helper class for building result strings in a character buffer. The
          81                 : // purpose of the class is to use safe operations that checks the
          82                 : // buffer bounds on all operations in debug mode.
          83                 : class StringBuilder {
          84                 :  public:
          85                 :
          86          234994 :   StringBuilder(char* buffer, int size)
          87          234994 :       : buffer_(buffer, size), position_(0) { }
          88                 :
          89          234994 :   ~StringBuilder() { if (!is_finalized()) Finalize(); }
          90                 :
          91                 :   // Add a single character to the builder. It is not allowed to add
          92                 :   // 0-characters; use the Finalize() method to terminate the string
          93                 :   // instead.
          94          352531 :   void AddCharacter(char c) {
          95          352531 :     ASSERT(c != '\0');
          96          352531 :     ASSERT(!is_finalized() && position_ < buffer_.length());
          97          352531 :     buffer_[position_++] = c;
          98          352531 :   }
          99                 :
         100                 :   // Add an entire string to the builder. Uses strlen() internally to
         101                 :   // compute the length of the input string.
         102                 :   void AddString(const char* s);
         103                 :
         104                 :   // Add the first 'n' characters of the given string 's' to the
         105                 :   // builder. The input string must have enough characters.
         106                 :   void AddSubstring(const char* s, int n);
         107                 :
         108                 :   // Add an integer to the builder.
         109                 :   void AddInteger(int n);
         110                 :
         111                 :   // Add character padding to the builder. If count is non-positive,
         112                 :   // nothing is added to the builder.
         113                 :   void AddPadding(char c, int count);
         114                 :
         115                 :   // Finalize the string by 0-terminating it and returning the buffer.
         116                 :   char* Finalize();
         117                 :
         118                 :  private:
         119                 :   Vector<char> buffer_;
         120                 :   int position_;
         121                 :
         122         1455801 :   bool is_finalized() const { return position_ < 0; }
         123                 :
         124                 :   DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
         125                 : };
         126                 :
         127                 :
         128                 : // The type-based aliasing rule allows the compiler to assume that pointers of
         129                 : // different types (for some definition of different) never alias each other.
         130                 : // Thus the following code does not work:
         131                 : //
         132                 : // float f = foo();
         133                 : // int fbits = *(int*)(&f);
         134                 : //
         135                 : // The compiler 'knows' that the int pointer can't refer to f since the types
         136                 : // don't match, so the compiler may cache f in a register, leaving random data
         137                 : // in fbits.  Using C++ style casts makes no difference, however a pointer to
         138                 : // char data is assumed to alias any other pointer.  This is the 'memcpy
         139                 : // exception'.
         140                 : //
         141                 : // Bit_cast uses the memcpy exception to move the bits from a variable of one
         142                 : // type of a variable of another type.  Of course the end result is likely to
         143                 : // be implementation dependent.  Most compilers (gcc-4.2 and MSVC 2005)
         144                 : // will completely optimize BitCast away.
         145                 : //
         146                 : // There is an additional use for BitCast.
         147                 : // Recent gccs will warn when they see casts that may result in breakage due to
         148                 : // the type-based aliasing rule.  If you have checked that there is no breakage
         149                 : // you can use BitCast to cast one pointer type to another.  This confuses gcc
         150                 : // enough that it can no longer see that you have cast one pointer type to
         151                 : // another thus avoiding the warning.
         152                 : template <class Dest, class Source>
         153         1065035 : inline Dest BitCast(const Source& source) {
         154                 :   // Compile time assertion: sizeof(Dest) == sizeof(Source)
         155                 :   // A compile error here means your Dest and Source have different sizes.
         156                 :   typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
         157                 :
         158                 :   Dest dest;
         159         1065035 :   memcpy(&dest, &source, sizeof(dest));
         160         1065035 :   return dest;
         161                 : }
         162                 :
         163                 : } }  // namespace v8::internal
         164                 :
         165                 : #endif  // V8_UTILS_H_

Generated by: LCOV version 1.7