Experimental: merge from bleeding_edge. Merge up to and including...

include/v8.h

 // Copyright 2007-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 182 matching lines @@
      * This check fails when trying to convert between incompatible
      * handles. For example, converting from a Handle<String> to a
      * Handle<Number>.
      */
     TYPE_CHECK(T, S);
   }
 
   /**
    * Returns true if the handle is empty.
    */
-  bool IsEmpty() { return val_ == 0; }
+  bool IsEmpty() const { return val_ == 0; }
 
-  T* operator->();
+  T* operator->() const;
 
-  T* operator*();
+  T* operator*() const;
 
   /**
    * Sets the handle to be empty. IsEmpty() will then return true.
    */
   void Clear() { this->val_ = 0; }
 
   /**
    * Checks whether two handles are the same.
    * Returns true if both are empty, or if the objects
    * to which they refer are identical.
    * The handles' references are not checked.
    */
-  template <class S> bool operator==(Handle<S> that) {
+  template <class S> bool operator==(Handle<S> that) const {
     void** a = reinterpret_cast<void**>(**this);
     void** b = reinterpret_cast<void**>(*that);
     if (a == 0) return b == 0;
     if (b == 0) return false;
     return *a == *b;
   }
 
   /**
    * Checks whether two handles are different.
    * Returns true if only one of the handles is empty, or if
    * the objects to which they refer are different.
    * The handles' references are not checked.
    */
-  template <class S> bool operator!=(Handle<S> that) {
+  template <class S> bool operator!=(Handle<S> that) const {
     return !operator==(that);
   }
 
   template <class S> static inline Handle<T> Cast(Handle<S> that) {
     if (that.IsEmpty()) return Handle<T>();
     return Handle<T>(T::Cast(*that));
   }
 
  private:
   T* val_;
@@ skipping 115 matching lines @@
    * it the object reference and the given parameters.
    */
   void MakeWeak(void* parameters, WeakReferenceCallback callback);
 
   /** Clears the weak reference to this object.*/
   void ClearWeak();
 
   /**
    *Checks if the handle holds the only reference to an object.
    */
-  bool IsNearDeath();
+  bool IsNearDeath() const;
 
   /**
    * Returns true if the handle's reference is weak.
    */
-  bool IsWeak();
+  bool IsWeak() const;
 
  private:
   friend class ImplementationUtilities;
   friend class ObjectTemplate;
 };
 
 
  /**
  * A stack-allocated class that governs a number of local handles.
  * After a handle scope has been created, all local handles will be
@@ skipping 163 matching lines @@
    */
   Local<Value> Run();
 };
 
 
 /**
  * An error message.
  */
 class EXPORT Message {
  public:
-  Local<String> Get();
-  Local<String> GetSourceLine();
+  Local<String> Get() const;
+  Local<String> GetSourceLine() const;
 
-  Handle<Value> GetScriptResourceName();
+  Handle<Value> GetScriptResourceName() const;
 
   /**
    * Returns the number, 1-based, of the line where the error occurred.
    */
-  int GetLineNumber();
+  int GetLineNumber() const;
 
   /**
    * Returns the index within the script of the first character where
    * the error occurred.
    */
-  int GetStartPosition();
+  int GetStartPosition() const;
 
   /**
    * Returns the index within the script of the last character where
    * the error occurred.
    */
-  int GetEndPosition();
+  int GetEndPosition() const;
 
   /**
    * Returns the index within the line of the first character where
    * the error occurred.
    */
-  int GetStartColumn();
+  int GetStartColumn() const;
 
   /**
    * Returns the index within the line of the last character where
    * the error occurred.
    */
-  int GetEndColumn();
+  int GetEndColumn() const;
 
   // TODO(1245381): Print to a string instead of on a FILE.
   static void PrintCurrentStackTrace(FILE* out);
 };
 
 
 // --- V a l u e ---
 
 
 /**
  * The superclass of all JavaScript values and objects.
  */
 class EXPORT Value : public Data {
  public:
 
   /**
    * Returns true if this value is the undefined value.  See ECMA-262
    * 4.3.10.
    */
-  bool IsUndefined();
+  bool IsUndefined() const;
 
   /**
    * Returns true if this value is the null value.  See ECMA-262
    * 4.3.11.
    */
-  bool IsNull();
+  bool IsNull() const;
 
    /**
    * Returns true if this value is true.
    */
-  bool IsTrue();
+  bool IsTrue() const;
 
   /**
    * Returns true if this value is false.
    */
-  bool IsFalse();
+  bool IsFalse() const;
 
   /**
    * Returns true if this value is an instance of the String type.
    * See ECMA-262 8.4.
    */
-  bool IsString();
+  bool IsString() const;
 
   /**
    * Returns true if this value is a function.
    */
-  bool IsFunction();
+  bool IsFunction() const;
 
   /**
    * Returns true if this value is an array.
    */
-  bool IsArray();
+  bool IsArray() const;
 
   /**
    * Returns true if this value is an object.
    */
-  bool IsObject();
+  bool IsObject() const;
 
   /**
    * Returns true if this value is boolean.
    */
-  bool IsBoolean();
+  bool IsBoolean() const;
 
   /**
    * Returns true if this value is a number.
    */
-  bool IsNumber();
+  bool IsNumber() const;
 
   /**
    * Returns true if this value is external.
    */
-  bool IsExternal();
+  bool IsExternal() const;
 
   /**
    * Returns true if this value is a 32-bit signed integer.
    */
-  bool IsInt32();
+  bool IsInt32() const;
 
   /**
    * Returns true if this value is a Date.
    */
-  bool IsDate();
+  bool IsDate() const;
 
-  Local<Boolean> ToBoolean();
-  Local<Number> ToNumber();
-  Local<String> ToString();
-  Local<String> ToDetailString();
-  Local<Object> ToObject();
-  Local<Integer> ToInteger();
-  Local<Uint32> ToUint32();
-  Local<Int32> ToInt32();
+  Local<Boolean> ToBoolean() const;
+  Local<Number> ToNumber() const;
+  Local<String> ToString() const;
+  Local<String> ToDetailString() const;
+  Local<Object> ToObject() const;
+  Local<Integer> ToInteger() const;
+  Local<Uint32> ToUint32() const;
+  Local<Int32> ToInt32() const;
 
   /**
    * Attempts to convert a string to an array index.
    * Returns an empty handle if the conversion fails.
    */
-  Local<Uint32> ToArrayIndex();
+  Local<Uint32> ToArrayIndex() const;
 
-  bool BooleanValue();
-  double NumberValue();
-  int64_t IntegerValue();
-  uint32_t Uint32Value();
-  int32_t Int32Value();
+  bool BooleanValue() const;
+  double NumberValue() const;
+  int64_t IntegerValue() const;
+  uint32_t Uint32Value() const;
+  int32_t Int32Value() const;
 
   /** JS == */
-  bool Equals(Handle<Value> that);
-  bool StrictEquals(Handle<Value> that);
+  bool Equals(Handle<Value> that) const;
+  bool StrictEquals(Handle<Value> that) const;
 };
 
 
 /**
  * The superclass of primitive values.  See ECMA-262 4.3.2.
  */
 class EXPORT Primitive : public Value { };
 
 
 /**
  * A primitive boolean value (ECMA-262, 4.3.14).  Either the true
  * or false value.
  */
 class EXPORT Boolean : public Primitive {
  public:
-  bool Value();
+  bool Value() const;
   static inline Handle<Boolean> New(bool value);
 };
 
 
 /**
  * A JavaScript string value (ECMA-262, 4.3.17).
  */
 class EXPORT String : public Primitive {
  public:
 
   /**
    * Returns the number of characters in this string.
    */
-  int Length();
+  int Length() const;
 
   /**
    * Returns the number of bytes in the UTF-8 encoded
    * representation of this string.
    */
-  int Utf8Length();
+  int Utf8Length() const;
 
   /**
    * Write the contents of the string to an external buffer.
    * If no arguments are given, expects the buffer to be large
    * enough to hold the entire string and NULL terminator. Copies
    * the contents of the string and the NULL terminator into the
    * buffer.
    *
    * Copies up to length characters into the output buffer.
    * Only null-terminates if there is enough space in the buffer.
    *
    * \param buffer The buffer into which the string will be copied.
    * \param start The starting position within the string at which
    * copying begins.
    * \param length The number of bytes to copy from the string.
    * \return The number of characters copied to the buffer
    * excluding the NULL terminator.
    */
-  int Write(uint16_t* buffer, int start = 0, int length = -1);  // UTF-16
-  int WriteAscii(char* buffer, int start = 0, int length = -1);  // ASCII
-  int WriteUtf8(char* buffer, int length = -1); // UTF-8
+  int Write(uint16_t* buffer, int start = 0, int length = -1) const;  // UTF-16
+  int WriteAscii(char* buffer, int start = 0, int length = -1) const;  // ASCII
+  int WriteUtf8(char* buffer, int length = -1) const; // UTF-8
 
   /**
    * Returns true if the string is external
    */
-  bool IsExternal();
+  bool IsExternal() const;
 
   /**
    * Returns true if the string is both external and ascii
    */
-  bool IsExternalAscii();
+  bool IsExternalAscii() const;
   /**
    * An ExternalStringResource is a wrapper around a two-byte string
    * buffer that resides outside V8's heap. Implement an
    * ExternalStringResource to manage the life cycle of the underlying
    * buffer.  Note that the string data must be immutable.
    */
   class EXPORT ExternalStringResource {  // NOLINT
    public:
     /**
      * Override the destructor to manage the life cycle of the underlying
@@ skipping 39 matching lines @@
    private:
     // Disallow copying and assigning.
     ExternalAsciiStringResource(const ExternalAsciiStringResource&);
     void operator=(const ExternalAsciiStringResource&);
   };
 
   /**
    * Get the ExternalStringResource for an external string.  Only
    * valid if IsExternal() returns true.
    */
-  ExternalStringResource* GetExternalStringResource();
+  ExternalStringResource* GetExternalStringResource() const;
 
   /**
    * Get the ExternalAsciiStringResource for an external ascii string.
    * Only valid if IsExternalAscii() returns true.
    */
-  ExternalAsciiStringResource* GetExternalAsciiStringResource();
+  ExternalAsciiStringResource* GetExternalAsciiStringResource() const;
 
   static String* Cast(v8::Value* obj);
 
   /**
    * Allocates a new string from either utf-8 encoded or ascii data.
    * The second parameter 'length' gives the buffer length.
    * If the data is utf-8 encoded, the caller must
    * be careful to supply the length parameter.
    * If it is not given, the function calls
    * 'strlen' to determine the buffer length, it might be
@@ skipping 89 matching lines @@
     void operator=(const Value&);
   };
 };
 
 
 /**
  * A JavaScript number value (ECMA-262, 4.3.20)
  */
 class EXPORT Number : public Primitive {
  public:
-  double Value();
+  double Value() const;
   static Local<Number> New(double value);
   static Number* Cast(v8::Value* obj);
  private:
   Number();
 };
 
 
 /**
  * A JavaScript value representing a signed integer.
  */
 class EXPORT Integer : public Number {
  public:
   static Local<Integer> New(int32_t value);
-  int64_t Value();
+  int64_t Value() const;
   static Integer* Cast(v8::Value* obj);
  private:
   Integer();
 };
 
 
 /**
  * A JavaScript value representing a 32-bit signed integer.
  */
 class EXPORT Int32 : public Integer {
  public:
-  int32_t Value();
+  int32_t Value() const;
  private:
   Int32();
 };
 
 
 /**
  * A JavaScript value representing a 32-bit unsigned integer.
  */
 class EXPORT Uint32 : public Integer {
  public:
-  uint32_t Value();
+  uint32_t Value() const;
  private:
   Uint32();
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
 class EXPORT Date : public Value {
  public:
   static Local<Value> New(double time);
 
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
    */
-  double NumberValue();
+  double NumberValue() const;
 
   static Date* Cast(v8::Value* obj);
 };
 
 
 enum PropertyAttribute {
   None       = 0,
   ReadOnly   = 1 << 0,
   DontEnum   = 1 << 1,
   DontDelete = 1 << 2
@@ skipping 74 matching lines @@
  private:
   Object();
 };
 
 
 /**
  * An instance of the built-in array constructor (ECMA-262, 15.4.2).
  */
 class EXPORT Array : public Object {
  public:
-  uint32_t Length();
+  uint32_t Length() const;
 
   static Local<Array> New(int length = 0);
   static Array* Cast(Value* obj);
  private:
   Array();
 };
 
 
 /**
  * A JavaScript function object (ECMA-262, 15.3).
  */
 class EXPORT Function : public Object {
  public:
-  Local<Object> NewInstance();
-  Local<Object> NewInstance(int argc, Handle<Value> argv[]);
+  Local<Object> NewInstance() const;
+  Local<Object> NewInstance(int argc, Handle<Value> argv[]) const;
   Local<Value> Call(Handle<Object> recv, int argc, Handle<Value> argv[]);
   void SetName(Handle<String> name);
-  Handle<Value> GetName();
+  Handle<Value> GetName() const;
   static Function* Cast(Value* obj);
  private:
   Function();
 };
 
 
 /**
  * A JavaScript value that wraps a c++ void*.  This type of value is
  * mainly used to associate c++ data structures with JavaScript
  * objects.
  */
 class EXPORT External : public Value {
  public:
   static Local<External> New(void* value);
   static External* Cast(Value* obj);
-  void* Value();
+  void* Value() const;
  private:
   External();
 };
 
 
 // --- T e m p l a t e s ---
 
 
 /**
  * The superclass of object and function templates.
@@ skipping 1180 matching lines @@
 
 template <class T>
 Persistent<T> Persistent<T>::New(Handle<T> that) {
   if (that.IsEmpty()) return Persistent<T>();
   void** p = reinterpret_cast<void**>(*that);
   return Persistent<T>(reinterpret_cast<T*>(V8::GlobalizeReference(p)));
 }
 
 
 template <class T>
-bool Persistent<T>::IsNearDeath() {
+bool Persistent<T>::IsNearDeath() const {
   if (this->IsEmpty()) return false;
   return V8::IsGlobalNearDeath(reinterpret_cast<void**>(**this));
 }
 
 
 template <class T>
-bool Persistent<T>::IsWeak() {
+bool Persistent<T>::IsWeak() const {
   if (this->IsEmpty()) return false;
   return V8::IsGlobalWeak(reinterpret_cast<void**>(**this));
 }
 
 
 template <class T>
 void Persistent<T>::Dispose() {
   if (this->IsEmpty()) return;
   V8::DisposeGlobal(reinterpret_cast<void**>(**this));
 }
 
 
 template <class T>
 Persistent<T>::Persistent() : Handle<T>() { }
 
 template <class T>
 void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback) {
   V8::MakeWeak(reinterpret_cast<void**>(**this), parameters, callback);
 }
 
 template <class T>
 void Persistent<T>::ClearWeak() {
   V8::ClearWeak(reinterpret_cast<void**>(**this));
 }
 
 template <class T>
-T* Handle<T>::operator->() {
+T* Handle<T>::operator->() const {
   return val_;
 }
 
 
 template <class T>
-T* Handle<T>::operator*() {
+T* Handle<T>::operator*() const {
   return val_;
 }
 
 
 Local<Value> Arguments::operator[](int i) const {
   if (i < 0 || length_ <= i) return Local<Value>(*Undefined());
   return Local<Value>(reinterpret_cast<Value*>(values_ - i));
 }
 
 
@@ skipping 87 matching lines @@
 
 }  // namespace v8
 
 
 #undef EXPORT
 #undef EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_