The Tor Browser: js/src/ctypes/CTypes.h@6474c204b198 (annotated)

js/src/ctypes/CTypes.h@6474c204b198 (annotated)

js/src/ctypes/CTypes.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*-  Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef ctypes_CTypes_h
 #define ctypes_CTypes_h
 #include "ffi.h"
 #include "jsalloc.h"
 #include "prlink.h"
 #include "js/HashTable.h"
 #include "js/Vector.h"
 #include "vm/String.h"
 namespace js {
 namespace ctypes {
 /*******************************************************************************
 ** Utility classes
 *******************************************************************************/
 // Class that takes ownership of a pointer T*, and calls cx->delete_() or
 // cx->array_delete() upon destruction.
 template<class T>
 class AutoPtr {
 private:
   typedef AutoPtr<T> self_type;
 public:
   AutoPtr() : mPtr(nullptr) { }
   explicit AutoPtr(T* ptr) : mPtr(ptr) { }
   ~AutoPtr() { js_delete(mPtr); }
   T*   operator->()         { return mPtr; }
   bool operator!()          { return mPtr == nullptr; }
   T&   operator[](size_t i) { return *(mPtr + i); }
   // Note: we cannot safely provide an 'operator T*()', since this would allow
   // the compiler to perform implicit conversion from one AutoPtr to another
   // via the constructor AutoPtr(T*).
   T*   get()         { return mPtr; }
   void set(T* other) { JS_ASSERT(mPtr == nullptr); mPtr = other; }
   T*   forget()      { T* result = mPtr; mPtr = nullptr; return result; }
   self_type& operator=(T* rhs) { mPtr = rhs; return *this; }
 private:
   // Do not allow copy construction or assignment from another AutoPtr.
   AutoPtr(AutoPtr<T>&);
   self_type& operator=(AutoPtr<T>& rhs);
   T* mPtr;
 };
 // Container class for Vector, using SystemAllocPolicy.
 template<class T, size_t N = 0>
 class Array : public Vector<T, N, SystemAllocPolicy>
 {
   static_assert(!mozilla::IsSame<T, JS::Value>::value,
                 "use JS::AutoValueVector instead");
 };
 // String and AutoString classes, based on Vector.
 typedef Vector<jschar,  0, SystemAllocPolicy> String;
 typedef Vector<jschar, 64, SystemAllocPolicy> AutoString;
 typedef Vector<char,    0, SystemAllocPolicy> CString;
 typedef Vector<char,   64, SystemAllocPolicy> AutoCString;
 // Convenience functions to append, insert, and compare Strings.
 template <class T, size_t N, class AP, size_t ArrayLength>
 void
 AppendString(Vector<T, N, AP> &v, const char (&array)[ArrayLength])
 {
   // Don't include the trailing '\0'.
   size_t alen = ArrayLength - 1;
   size_t vlen = v.length();
   if (!v.resize(vlen + alen))
     return;
   for (size_t i = 0; i < alen; ++i)
     v[i + vlen] = array[i];
 }
 template <class T, size_t N, size_t M, class AP>
 void
 AppendString(Vector<T, N, AP> &v, Vector<T, M, AP> &w)
 {
   v.append(w.begin(), w.length());
 }
 template <size_t N, class AP>
 void
 AppendString(Vector<jschar, N, AP> &v, JSString* str)
 {
   JS_ASSERT(str);
   const jschar *chars = str->getChars(nullptr);
   if (!chars)
     return;
   v.append(chars, str->length());
 }
 template <size_t N, class AP>
 void
 AppendString(Vector<char, N, AP> &v, JSString* str)
 {
   JS_ASSERT(str);
   size_t vlen = v.length();
   size_t alen = str->length();
   if (!v.resize(vlen + alen))
     return;
   const jschar *chars = str->getChars(nullptr);
   if (!chars)
     return;
   for (size_t i = 0; i < alen; ++i)
     v[i + vlen] = char(chars[i]);
 }
 template <class T, size_t N, class AP, size_t ArrayLength>
 void
 PrependString(Vector<T, N, AP> &v, const char (&array)[ArrayLength])
 {
   // Don't include the trailing '\0'.
   size_t alen = ArrayLength - 1;
   size_t vlen = v.length();
   if (!v.resize(vlen + alen))
     return;
   // Move vector data forward. This is safe since we've already resized.
   memmove(v.begin() + alen, v.begin(), vlen * sizeof(T));
   // Copy data to insert.
   for (size_t i = 0; i < alen; ++i)
     v[i] = array[i];
 }
 template <size_t N, class AP>
 void
 PrependString(Vector<jschar, N, AP> &v, JSString* str)
 {
   JS_ASSERT(str);
   size_t vlen = v.length();
   size_t alen = str->length();
   if (!v.resize(vlen + alen))
     return;
   const jschar *chars = str->getChars(nullptr);
   if (!chars)
     return;
   // Move vector data forward. This is safe since we've already resized.
   memmove(v.begin() + alen, v.begin(), vlen * sizeof(jschar));
   // Copy data to insert.
   memcpy(v.begin(), chars, alen * sizeof(jschar));
 }
 extern size_t
 GetDeflatedUTF8StringLength(JSContext *maybecx, const jschar *chars,
                             size_t charsLength);
 bool
 DeflateStringToUTF8Buffer(JSContext *maybecx, const jschar *src, size_t srclen,
                           char *dst, size_t *dstlenp);
 /*******************************************************************************
 ** Function and struct API definitions
 *******************************************************************************/
 MOZ_ALWAYS_INLINE void
 ASSERT_OK(bool ok)
 {
   JS_ASSERT(ok);
 }
 // for JS error reporting
 enum ErrorNum {
 #define MSG_DEF(name, number, count, exception, format) \
   name = number,
 #include "ctypes/ctypes.msg"
 #undef MSG_DEF
   CTYPESERR_LIMIT
 };
 /**
  * ABI constants that specify the calling convention to use.
  * ctypes.default_abi corresponds to the cdecl convention, and in almost all
  * cases is the correct choice. ctypes.stdcall_abi is provided for calling
  * stdcall functions on Win32, and implies stdcall symbol name decoration;
  * ctypes.winapi_abi is just stdcall but without decoration.
  */
 enum ABICode {
   ABI_DEFAULT,
   ABI_STDCALL,
   ABI_WINAPI,
   INVALID_ABI
 };
 enum TypeCode {
   TYPE_void_t,
 #define DEFINE_TYPE(name, type, ffiType) TYPE_##name,
 #include "ctypes/typedefs.h"
   TYPE_pointer,
   TYPE_function,
   TYPE_array,
   TYPE_struct
 };
 // Descriptor of one field in a StructType. The name of the field is stored
 // as the key to the hash entry.
 struct FieldInfo
 {
   JS::Heap<JSObject*> mType;    // CType of the field
   size_t              mIndex;   // index of the field in the struct (first is 0)
   size_t              mOffset;  // offset of the field in the struct, in bytes
 };
 struct UnbarrieredFieldInfo
 {
   JSObject*           mType;    // CType of the field
   size_t              mIndex;   // index of the field in the struct (first is 0)
   size_t              mOffset;  // offset of the field in the struct, in bytes
 };
 static_assert(sizeof(UnbarrieredFieldInfo) == sizeof(FieldInfo),
               "UnbarrieredFieldInfo should be the same as FieldInfo but with unbarriered mType");
 // Hash policy for FieldInfos.
 struct FieldHashPolicy : DefaultHasher<JSFlatString*>
 {
   typedef JSFlatString* Key;
   typedef Key Lookup;
   static uint32_t hash(const Lookup &l) {
     const jschar* s = l->chars();
     size_t n = l->length();
     uint32_t hash = 0;
     for (; n > 0; s++, n--)
       hash = hash * 33 + *s;
     return hash;
   }
   static bool match(const Key &k, const Lookup &l) {
     if (k == l)
       return true;
     if (k->length() != l->length())
       return false;
     return memcmp(k->chars(), l->chars(), k->length() * sizeof(jschar)) == 0;
   }
 };
 typedef HashMap<JSFlatString*, FieldInfo, FieldHashPolicy, SystemAllocPolicy> FieldInfoHash;
 // Descriptor of ABI, return type, argument types, and variadicity for a
 // FunctionType.
 struct FunctionInfo
 {
   // Initialized in NewFunctionInfo when !mIsVariadic, but only later, in
   // FunctionType::Call, when mIsVariadic. Not always consistent with
   // mFFITypes, due to lazy initialization when mIsVariadic.
   ffi_cif mCIF;
   // Calling convention of the function. Convert to ffi_abi using GetABI
   // and OBJECT_TO_JSVAL. Stored as a JSObject* for ease of tracing.
   JS::Heap<JSObject*> mABI;
   // The CType of the value returned by the function.
   JS::Heap<JSObject*> mReturnType;
   // A fixed array of known parameter types, excluding any variadic
   // parameters (if mIsVariadic).
   Array<JS::Heap<JSObject*> > mArgTypes;
   // A variable array of ffi_type*s corresponding to both known parameter
   // types and dynamic (variadic) parameter types. Longer than mArgTypes
   // only if mIsVariadic.
   Array<ffi_type*> mFFITypes;
   // Flag indicating whether the function behaves like a C function with
   // ... as the final formal parameter.
   bool mIsVariadic;
 };
 // Parameters necessary for invoking a JS function from a C closure.
 struct ClosureInfo
 {
   JSContext* cx;                   // JSContext to use
   JSRuntime* rt;                   // Used in the destructor, where cx might have already
                                    // been GCed.
   JS::Heap<JSObject*> closureObj;  // CClosure object
   JS::Heap<JSObject*> typeObj;     // FunctionType describing the C function
   JS::Heap<JSObject*> thisObj;     // 'this' object to use for the JS function call
   JS::Heap<JSObject*> jsfnObj;     // JS function
   void* errResult;                 // Result that will be returned if the closure throws
   ffi_closure* closure;            // The C closure itself
   // Anything conditionally freed in the destructor should be initialized to
   // nullptr here.
   ClosureInfo(JSRuntime* runtime)
     : rt(runtime)
     , errResult(nullptr)
     , closure(nullptr)
   {}
   ~ClosureInfo() {
     if (closure)
       ffi_closure_free(closure);
     js_free(errResult);
   }
 };
 bool IsCTypesGlobal(HandleValue v);
 bool IsCTypesGlobal(JSObject* obj);
 JSCTypesCallbacks* GetCallbacks(JSObject* obj);
 /*******************************************************************************
 ** JSClass reserved slot definitions
 *******************************************************************************/
 enum CTypesGlobalSlot {
   SLOT_CALLBACKS = 0, // pointer to JSCTypesCallbacks struct
   SLOT_ERRNO = 1,     // jsval for latest |errno|
   SLOT_LASTERROR = 2, // jsval for latest |GetLastError|, used only with Windows
   CTYPESGLOBAL_SLOTS
 };
 enum CABISlot {
   SLOT_ABICODE = 0, // ABICode of the CABI object
   CABI_SLOTS
 };
 enum CTypeProtoSlot {
   SLOT_POINTERPROTO      = 0,  // ctypes.PointerType.prototype object
   SLOT_ARRAYPROTO        = 1,  // ctypes.ArrayType.prototype object
   SLOT_STRUCTPROTO       = 2,  // ctypes.StructType.prototype object
   SLOT_FUNCTIONPROTO     = 3,  // ctypes.FunctionType.prototype object
   SLOT_CDATAPROTO        = 4,  // ctypes.CData.prototype object
   SLOT_POINTERDATAPROTO  = 5,  // common ancestor of all CData objects of PointerType
   SLOT_ARRAYDATAPROTO    = 6,  // common ancestor of all CData objects of ArrayType
   SLOT_STRUCTDATAPROTO   = 7,  // common ancestor of all CData objects of StructType
   SLOT_FUNCTIONDATAPROTO = 8,  // common ancestor of all CData objects of FunctionType
   SLOT_INT64PROTO        = 9,  // ctypes.Int64.prototype object
   SLOT_UINT64PROTO       = 10, // ctypes.UInt64.prototype object
   SLOT_CTYPES            = 11, // ctypes object
   SLOT_OURDATAPROTO      = 12, // the data prototype corresponding to this object
   CTYPEPROTO_SLOTS
 };
 enum CTypeSlot {
   SLOT_PROTO     = 0, // 'prototype' property of the CType object
   SLOT_TYPECODE  = 1, // TypeCode of the CType object
   SLOT_FFITYPE   = 2, // ffi_type representing the type
   SLOT_NAME      = 3, // name of the type
   SLOT_SIZE      = 4, // size of the type, in bytes
   SLOT_ALIGN     = 5, // alignment of the type, in bytes
   SLOT_PTR       = 6, // cached PointerType object for type.ptr
   // Note that some of the slots below can overlap, since they're for
   // mutually exclusive types.
   SLOT_TARGET_T  = 7, // (PointerTypes only) 'targetType' property
   SLOT_ELEMENT_T = 7, // (ArrayTypes only) 'elementType' property
   SLOT_LENGTH    = 8, // (ArrayTypes only) 'length' property
   SLOT_FIELDS    = 7, // (StructTypes only) 'fields' property
   SLOT_FIELDINFO = 8, // (StructTypes only) FieldInfoHash table
   SLOT_FNINFO    = 7, // (FunctionTypes only) FunctionInfo struct
   SLOT_ARGS_T    = 8, // (FunctionTypes only) 'argTypes' property (cached)
   CTYPE_SLOTS
 };
 enum CDataSlot {
   SLOT_CTYPE    = 0, // CType object representing the underlying type
   SLOT_REFERENT = 1, // JSObject this object must keep alive, if any
   SLOT_DATA     = 2, // pointer to a buffer containing the binary data
   SLOT_OWNS     = 3, // JSVAL_TRUE if this CData owns its own buffer
   CDATA_SLOTS
 };
 enum CClosureSlot {
   SLOT_CLOSUREINFO = 0, // ClosureInfo struct
   CCLOSURE_SLOTS
 };
 enum CDataFinalizerSlot {
   // The type of the value (a CType JSObject).
   // We hold it to permit ImplicitConvert and ToSource.
   SLOT_DATAFINALIZER_VALTYPE           = 0,
   // The type of the function used at finalization (a CType JSObject).
   // We hold it to permit |ToSource|.
   SLOT_DATAFINALIZER_CODETYPE          = 1,
   CDATAFINALIZER_SLOTS
 };
 enum TypeCtorSlot {
   SLOT_FN_CTORPROTO = 0 // ctypes.{Pointer,Array,Struct}Type.prototype
   // JSFunction objects always get exactly two slots.
 };
 enum Int64Slot {
   SLOT_INT64 = 0, // pointer to a 64-bit buffer containing the integer
   INT64_SLOTS
 };
 enum Int64FunctionSlot {
   SLOT_FN_INT64PROTO = 0 // ctypes.{Int64,UInt64}.prototype object
   // JSFunction objects always get exactly two slots.
 };
 /*******************************************************************************
 ** Object API definitions
 *******************************************************************************/
 namespace CType {
   JSObject* Create(JSContext* cx, HandleObject typeProto, HandleObject dataProto,
     TypeCode type, JSString* name, jsval size, jsval align, ffi_type* ffiType);
   JSObject* DefineBuiltin(JSContext* cx, JSObject* parent, const char* propName,
     JSObject* typeProto, JSObject* dataProto, const char* name, TypeCode type,
     jsval size, jsval align, ffi_type* ffiType);
   bool IsCType(JSObject* obj);
   bool IsCTypeProto(JSObject* obj);
   TypeCode GetTypeCode(JSObject* typeObj);
   bool TypesEqual(JSObject* t1, JSObject* t2);
   size_t GetSize(JSObject* obj);
   bool GetSafeSize(JSObject* obj, size_t* result);
   bool IsSizeDefined(JSObject* obj);
   size_t GetAlignment(JSObject* obj);
   ffi_type* GetFFIType(JSContext* cx, JSObject* obj);
   JSString* GetName(JSContext* cx, HandleObject obj);
   JSObject* GetProtoFromCtor(JSObject* obj, CTypeProtoSlot slot);
   JSObject* GetProtoFromType(JSContext* cx, JSObject* obj, CTypeProtoSlot slot);
   JSCTypesCallbacks* GetCallbacksFromType(JSObject* obj);
 }
 namespace PointerType {
   JSObject* CreateInternal(JSContext* cx, HandleObject baseType);
   JSObject* GetBaseType(JSObject* obj);
 }
 namespace ArrayType {
   JSObject* CreateInternal(JSContext* cx, HandleObject baseType, size_t length,
     bool lengthDefined);
   JSObject* GetBaseType(JSObject* obj);
   size_t GetLength(JSObject* obj);
   bool GetSafeLength(JSObject* obj, size_t* result);
   ffi_type* BuildFFIType(JSContext* cx, JSObject* obj);
 }
 namespace StructType {
   bool DefineInternal(JSContext* cx, JSObject* typeObj, JSObject* fieldsObj);
   const FieldInfoHash* GetFieldInfo(JSObject* obj);
   const FieldInfo* LookupField(JSContext* cx, JSObject* obj, JSFlatString *name);
   JSObject* BuildFieldsArray(JSContext* cx, JSObject* obj);
   ffi_type* BuildFFIType(JSContext* cx, JSObject* obj);
 }
 namespace FunctionType {
   JSObject* CreateInternal(JSContext* cx, jsval abi, jsval rtype,
     jsval* argtypes, unsigned arglen);
   JSObject* ConstructWithObject(JSContext* cx, JSObject* typeObj,
     JSObject* refObj, PRFuncPtr fnptr, JSObject* result);
   FunctionInfo* GetFunctionInfo(JSObject* obj);
   void BuildSymbolName(JSString* name, JSObject* typeObj,
     AutoCString& result);
 }
 namespace CClosure {
   JSObject* Create(JSContext* cx, HandleObject typeObj, HandleObject fnObj,
     HandleObject thisObj, jsval errVal, PRFuncPtr* fnptr);
 }
 namespace CData {
   JSObject* Create(JSContext* cx, HandleObject typeObj, HandleObject refObj,
     void* data, bool ownResult);
   JSObject* GetCType(JSObject* dataObj);
   void* GetData(JSObject* dataObj);
   bool IsCData(JSObject* obj);
   bool IsCData(HandleValue v);
   bool IsCDataProto(JSObject* obj);
   // Attached by JSAPI as the function 'ctypes.cast'
   bool Cast(JSContext* cx, unsigned argc, jsval* vp);
   // Attached by JSAPI as the function 'ctypes.getRuntime'
   bool GetRuntime(JSContext* cx, unsigned argc, jsval* vp);
 }
 namespace Int64 {
   bool IsInt64(JSObject* obj);
 }
 namespace UInt64 {
   bool IsUInt64(JSObject* obj);
 }
 }
 }
 #endif /* ctypes_CTypes_h */

The Tor Browser / annotate

js/src/ctypes/CTypes.h@6474c204b198 (annotated)

js/src/ctypes/CTypes.h