Merged bleeding edge 746:795 into regexp2000.

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 1793 matching lines @@
 class EXPORT Exception {
  public:
   static Local<Value> RangeError(Handle<String> message);
   static Local<Value> ReferenceError(Handle<String> message);
   static Local<Value> SyntaxError(Handle<String> message);
   static Local<Value> TypeError(Handle<String> message);
   static Local<Value> Error(Handle<String> message);
 };
 
 
-// --- C o u n t e r s  C a l l b a c k s
+// --- C o u n t e r s  C a l l b a c k s ---
 
 typedef int* (*CounterLookupCallback)(const wchar_t* name);
 
 // --- F a i l e d A c c e s s C h e c k C a l l b a c k ---
 typedef void (*FailedAccessCheckCallback)(Local<Object> target,
                                           AccessType type,
                                           Local<Value> data);
 
 // --- G a r b a g e C o l l e c t i o n  C a l l b a c k s
 
 /**
  * Applications can register a callback function which is called
  * before and after a major garbage collection.  Allocations are not
  * allowed in the callback function, you therefore cannot manipulate
  * objects (set or delete properties for example) since it is possible
  * such operations will result in the allocation of objects.
  */
 typedef void (*GCCallback)();
 
 
-//  --- C o n t e x t  G e n e r a t o r
+// --- E x t e r n a l  S y m b o l  C a l l b a c k ---
+
+/**
+ * Callback used to allocate certain V8 symbols as external strings.
+ *
+ * The data passed to the callback is utf8 encoded.
+ *
+ * Allocations are not allowed in the callback function, you therefore
+ * cannot manipulate objects (set or delete properties for example)
+ * since it is possible such operations will result in the allocation
+ * of objects.
+ */
+typedef String::ExternalStringResource* (*ExternalSymbolCallback)(
+    const char* utf8,
+    size_t length);
+
+
+// --- C o n t e x t  G e n e r a t o r ---
 
 /**
  * Applications must provide a callback function which is called to generate
  * a context if a context was not deserialized from the snapshot.
  */
 typedef Persistent<Context> (*ContextGenerator)();
 
 
 /**
  * Container class for static utility functions.
@@ skipping 79 matching lines @@
   /**
    * Enables the host application to receive a notification after a
    * major garbage collection.  Allocations are not allowed in the
    * callback function, you therefore cannot manipulate objects (set
    * or delete properties for example) since it is possible such
    * operations will result in the allocation of objects.
    */
   static void SetGlobalGCEpilogueCallback(GCCallback);
 
   /**
+   * Applications can register a callback that will be used when
+   * allocating most of the V8 symbols.  The callback must return an
+   * external string resource that represents the symbols.
+   *
+   * Most often when performing a property lookup the key will be a
+   * symbol.  Allocating symbols as external strings can reduce the
+   * amount of string conversions needed when using interceptors and
+   * accessors.
+   *
+   * \note This is an experimental feature and it might be removed.
+   */
+  static void SetExternalSymbolCallback(ExternalSymbolCallback);
+
+  /**
    * Allows the host application to group objects together. If one
    * object in the group is alive, all objects in the group are alive.
    * After each garbage collection, object groups are removed. It is
    * intended to be used in the before-garbage-collection callback
    * function for istance to simulate DOM tree connections among JS
    * wrapper objects.
    */
   static void AddObjectToGroup(void* id, Persistent<Object> obj);
 
   /**
@@ skipping 487 matching lines @@
 
 }  // namespace v8
 
 
 #undef EXPORT
 #undef EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_