diff options
Diffstat (limited to 'src/libs/xpcom18a4/xpcom/build')
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/.cvsignore | 1 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/Makefile.in | 165 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/dlldeps.cpp | 202 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/malloc.c | 5126 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/nsOS2VACLegacy.cpp | 753 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/nsStringAPI.cpp | 261 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/nsXPCOM.h | 217 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/nsXPCOMCID.h | 174 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/nsXPCOMPrivate.h | 228 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/nsXPComInit.cpp | 1079 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/win32.order | 1514 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/xpcom-tests.pkg | 47 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/xpcom.pkg | 106 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/build/xpcom_alpha.def | 252 |
14 files changed, 10125 insertions, 0 deletions
diff --git a/src/libs/xpcom18a4/xpcom/build/.cvsignore b/src/libs/xpcom18a4/xpcom/build/.cvsignore new file mode 100644 index 00000000..f3c7a7c5 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/.cvsignore @@ -0,0 +1 @@ +Makefile diff --git a/src/libs/xpcom18a4/xpcom/build/Makefile.in b/src/libs/xpcom18a4/xpcom/build/Makefile.in new file mode 100644 index 00000000..5c2386ce --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/Makefile.in @@ -0,0 +1,165 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is mozilla.org code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1998 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either of the GNU General Public License Version 2 or later (the "GPL"), +# or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +DEPTH = ../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +MODULE = xpcom +LIBRARY_NAME = xpcom + +PACKAGE_FILE = xpcom.pkg +PACKAGE_VARS += USE_SHORT_LIBNAME + +ifdef ENABLE_TESTS +PACKAGE_FILE += xpcom-tests.pkg +endif + +# Do not set EXPORT_LIBRARY as we do not want xpcom in the static libs list +#EXPORT_LIBRARY = 1 +GRE_MODULE = 1 + +REQUIRES = string \ + $(NULL) + +# pull in MoreFiles for MacOSX +ifneq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT))) +REQUIRES += macmorefiles +endif + +CPPSRCS = nsXPComInit.cpp \ + nsStringAPI.cpp \ + $(NULL) + +ifeq ($(OS_ARCH),WINNT) +CPPSRCS += dlldeps.cpp +endif + +ifdef XPCOM_USE_LEA +CSRCS += malloc.c +endif + +ifeq ($(OS_TARGET),OS2) +CPPSRCS += nsOS2VACLegacy.cpp +endif + +ifdef GC_LEAK_DETECTOR +EXTRA_DSO_LIBS = boehm +endif + +SHARED_LIBRARY_LIBS = \ + $(DIST)/lib/$(LIB_PREFIX)xpcomds_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpcomio_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpcomcomponents_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpcomthreads_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpcomproxy_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpcombase_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xptcall.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xptinfo.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpt.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xptcmd.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)string_s.$(LIB_SUFFIX) \ + $(DIST)/lib/$(LIB_PREFIX)xpcomglue_s.$(LIB_SUFFIX) \ + $(NULL) + +LOCAL_INCLUDES = \ + -I.. \ + -I$(srcdir)/../glue \ + -I$(srcdir)/../base \ + -I$(srcdir)/../ds \ + -I$(srcdir)/../io \ + -I$(srcdir)/../components \ + -I$(srcdir)/../threads \ + -I$(srcdir)/../threads/_xpidlgen \ + -I$(srcdir)/../proxy/src \ + $(NULL) + +SDK_HEADERS = \ + nsXPCOM.h \ + nsXPCOMCID.h \ + $(NULL) + +SDK_LIBRARY = $(IMPORT_LIBRARY) +SDK_BINARY = $(SHARED_LIBRARY) + +# pull in MoreFiles for MacOSX +ifneq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT))) +EXTRA_DSO_LIBS = macmorefiles_s +EXTRA_DSO_LDOPTS += $(EXTRA_DSO_LIBS) +EXTRA_DEPS += $(DIST)/lib/$(LIB_PREFIX)macmorefiles_s.$(LIB_SUFFIX) +endif + +# Force use of PIC +FORCE_USE_PIC = 1 + +FORCE_SHARED_LIB = 1 + +# UNIX98 iconv support +OS_LIBS += $(LIBICONV) + +include $(topsrcdir)/config/rules.mk + +DEFINES += \ + -D_IMPL_NS_COM \ + -DEXPORT_XPT_API \ + -DEXPORT_XPTC_API \ + -DEXPORT_XPTI_API + +EXTRA_DSO_LDOPTS += $(NSPR_LIBS) + +ifdef GC_LEAK_DETECTOR +DEFINES += -DGC_LEAK_DETECTOR +endif + +ifneq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT))) +CXXFLAGS += $(TK_CFLAGS) +EXTRA_DSO_LDOPTS += $(TK_LIBS) +endif + +ifeq ($(OS_ARCH),BeOS) +EXTRA_DSO_LDOPTS += -lbe +endif + +ifeq ($(OS_ARCH),WINNT) +EXTRA_DSO_LDOPTS += $(call EXPAND_LIBNAME,shell32 ole32 uuid) +ifneq (,$(MOZ_DEBUG)$(NS_TRACE_MALLOC)) +EXTRA_DSO_LDOPTS += $(call EXPAND_LIBNAME,imagehlp) +endif +endif # WINNT diff --git a/src/libs/xpcom18a4/xpcom/build/dlldeps.cpp b/src/libs/xpcom18a4/xpcom/build/dlldeps.cpp new file mode 100644 index 00000000..5fc31189 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/dlldeps.cpp @@ -0,0 +1,202 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +// Force references to all of the symbols that we want exported from +// the dll that are located in the .lib files we link with + +#include "nsVoidArray.h" +#include "nsValueArray.h" +#include "nsIAtom.h" +//#include "nsIBuffer.h" +#include "nsIByteArrayInputStream.h" +#include "nsFixedSizeAllocator.h" +#include "nsRecyclingAllocator.h" +#include "nsIThread.h" +#include "nsDeque.h" +#include "nsTraceRefcnt.h" +#include "nsTraceRefcntImpl.h" +#include "nsXPIDLString.h" +#include "nsIEnumerator.h" +#include "nsEnumeratorUtils.h" +#include "nsQuickSort.h" +#include "nsString.h" +#include "nsPrintfCString.h" +#include "nsSupportsArray.h" +#include "nsArray.h" +#include "nsArrayEnumerator.h" +#include "nsProxyEventPrivate.h" +#include "nsProxyRelease.h" +#include "xpt_xdr.h" +#include "xptcall.h" +#include "nsILocalFile.h" +#include "nsIGenericFactory.h" +#include "nsIPipe.h" +#include "nsStreamUtils.h" +#include "nsWeakReference.h" +#include "nsTextFormatter.h" +#include "nsIStorageStream.h" +#include "nsLinebreakConverter.h" +#include "nsIBinaryInputStream.h" +#include "nsIInterfaceRequestor.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsReadableUtils.h" +#include "nsStaticNameTable.h" +#include "nsProcess.h" +#include "nsStringEnumerator.h" +#include "nsIInputStreamTee.h" +#include "nsCheapSets.h" +#ifdef DEBUG +#include "pure.h" +#endif +#include "nsHashKeys.h" +#include "nsTHashtable.h" +#include "pldhash.h" +#include "nsVariant.h" +#include "nsEscape.h" +#include "nsStreamUtils.h" + +#define NS_STRINGAPI_IMPL +#include "nsStringAPI.h" + +void XXXNeverCalled() +{ + nsTextFormatter::snprintf(nsnull,0,nsnull); + nsTextFormatter::smprintf(nsnull, nsnull); + nsTextFormatter::smprintf_free(nsnull); + nsVoidArray(); + nsSmallVoidArray(); + nsStringHashSet(); + nsCStringHashSet(); + nsInt32HashSet(); + nsVoidHashSet(); + nsCheapStringSet(); + nsCheapInt32Set(); + nsValueArray(0); + nsSupportsArray(); + NS_GetNumberOfAtoms(); + NS_NewPipe2(nsnull, nsnull, PR_FALSE, PR_FALSE, 0, 0, nsnull); + NS_NewInputStreamReadyEvent(nsnull, nsnull, nsnull); + NS_NewOutputStreamReadyEvent(nsnull, nsnull, nsnull); + NS_AsyncCopy(nsnull, nsnull, nsnull, NS_ASYNCCOPY_VIA_READSEGMENTS, 0, nsnull, nsnull); + PL_DHashStubEnumRemove(nsnull, nsnull, nsnull, nsnull); + nsIDHashKey::HashKey(nsnull); + nsFixedSizeAllocator a; + nsRecyclingAllocator recyclingAllocator(2); + a.Init(0, 0, 0, 0, 0); + a.Alloc(0); + a.Free(0, 0); + nsIThread::GetCurrent(nsnull); + nsDeque(nsnull); + nsTraceRefcnt::LogAddCOMPtr(nsnull, nsnull); + nsTraceRefcntImpl::DumpStatistics(); + NS_NewEmptyEnumerator(nsnull); + new nsArrayEnumerator(nsnull); + NS_QuickSort(nsnull, 0, 0, nsnull, nsnull); + nsString(); + nsProxyObject(nsnull, 0, nsnull); + NS_ProxyRelease(nsnull, nsnull, PR_FALSE); + XPT_DoString(nsnull, nsnull, nsnull); + XPT_DoHeader(nsnull, nsnull, nsnull); +#ifdef DEBUG + PurePrintf(0); +#endif + XPTC_InvokeByIndex(nsnull, 0, 0, nsnull); + xptc_dummy(); + xptc_dummy2(); + XPTI_GetInterfaceInfoManager(); + NS_NewGenericFactory(nsnull, nsnull); + NS_NewGenericModule2(nsnull, nsnull); + NS_GetWeakReference(nsnull); + nsCOMPtr<nsISupports> dummyFoo(do_GetInterface(nsnull)); + NS_NewByteArrayInputStream(nsnull, nsnull, 0); + NS_NewStorageStream(0,0, nsnull); + nsString foo; + nsPrintfCString bar(""); + nsLinebreakConverter::ConvertStringLineBreaks(foo, + nsLinebreakConverter::eLinebreakAny, nsLinebreakConverter::eLinebreakContent); + NS_NewLocalFile(nsString(), PR_FALSE, nsnull); + NS_NewNativeLocalFile(nsCString(), PR_FALSE, nsnull); + new nsProcess(); + nsStaticCaseInsensitiveNameTable(); + nsAutoString str1; + str1.AssignWithConversion(nsnull, 0); + nsCAutoString str2; + ToNewUnicode(str1); + ToNewUnicode(str2); + ToNewCString(str1); + ToNewCString(str2); + PL_DHashTableFinish(nsnull); + NS_NewInputStreamTee(nsnull, nsnull, nsnull); + NS_NewArray(nsnull); + nsCOMArray<nsISupports> dummyArray; + NS_NewArray(nsnull, dummyArray); + NS_NewArrayEnumerator(nsnull, dummyArray); + new nsVariant(); + nsUnescape(nsnull); + nsEscape(nsnull, url_XAlphas); + nsStringArray array; + NS_NewStringEnumerator(nsnull, &array); + NS_NewAdoptingStringEnumerator(nsnull, &array); + nsCStringArray carray; + NS_NewUTF8StringEnumerator(nsnull, &carray); + NS_NewAdoptingUTF8StringEnumerator(nsnull, &carray); + nsVoidableString str3; + nsCStringContainer sc1; + NS_CStringContainerInit(sc1); + NS_CStringContainerFinish(sc1); + NS_CStringGetData(str2, nsnull, nsnull); + NS_CStringSetData(str2, nsnull, 0); + NS_CStringSetDataRange(str2, 0, 0, nsnull, 0); + NS_CStringCopy(str2, str2); + nsStringContainer sc2; + NS_StringContainerInit(sc2); + NS_StringContainerFinish(sc2); + NS_StringGetData(str1, nsnull, nsnull); + NS_StringSetData(str1, nsnull, 0); + NS_StringSetDataRange(str1, 0, 0, nsnull, 0); + NS_StringCopy(str1, str1); + { + nsAdoptingCString foo, bar; + foo = bar; + } + { + nsAdoptingString foo, bar; + foo = bar; + } + NS_UTF16ToCString(str1, NS_CSTRING_ENCODING_ASCII, str2); + NS_CStringToUTF16(str2, NS_CSTRING_ENCODING_ASCII, str1); +} diff --git a/src/libs/xpcom18a4/xpcom/build/malloc.c b/src/libs/xpcom18a4/xpcom/build/malloc.c new file mode 100644 index 00000000..96691829 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/malloc.c @@ -0,0 +1,5126 @@ +#define USE_MALLOC_LOCK +#define DEFAULT_TRIM_THRESHOLD (256 * 1024) + +/* ---------- To make a malloc.h, start cutting here ------------ */ + +/* + **************************************************************** + * THIS IS A PRERELEASE. It has not yet been tested adequately. * + * If you use it, please send back comments, suggestions, * + * performance reports, etc. * + **************************************************************** +*/ + +/* + A version (aka dlmalloc) of malloc/free/realloc written by Doug + Lea and released to the public domain. Use this code without + permission or acknowledgement in any way you wish. Send questions, + comments, complaints, performance data, etc to dl@cs.oswego.edu + +* VERSION 2.7.0pre7 Wed Jan 10 13:33:01 2001 Doug Lea (dl at gee) + + Note: There may be an updated version of this malloc obtainable at + ftp://gee.cs.oswego.edu/pub/misc/malloc.c + Check before installing! + +* Quickstart + + This library is all in one file to simplify the most common usage: + ftp it, compile it (-O), and link it into another program. All + of the compile-time options default to reasonable values for use on + most unix platforms. Compile -DWIN32 for reasonable defaults on windows. + You might later want to step through various compile options. + +* Why use this malloc? + + This is not the fastest, most space-conserving, most portable, or + most tunable malloc ever written. However it is among the fastest + while also being among the most space-conserving, portable and tunable. + Consistent balance across these factors results in a good general-purpose + allocator for malloc-intensive programs. + + The main properties of the algorithms are: + * For large (>= 512 bytes) requests, it is a pure best-fit allocator, + with ties normally decided via FIFO (i.e. least recently used). + * For small (<= 64 bytes by default) requests, it is a caching + allocator, that maintains pools of quickly recycled chunks. + * In between, and for combinations of large and small requests, it does + the best it can trying to meet both goals at once. + + Compared to 2.6.X versions, this version is generally faster, + especially for programs that allocate and free many small chunks. + + For a longer but slightly out of date high-level description, see + http://gee.cs.oswego.edu/dl/html/malloc.html + + You may already by default be using a c library containing a malloc + that is somehow based on some version of this malloc (for example in + linux). You might still want to use the one in this file in order to + customize settings or to avoid overheads associated with library + versions. + +* Synopsis of public routines + + (Much fuller descriptions are contained in the program documentation below.) + + malloc(size_t n); + Return a pointer to a newly allocated chunk of at least n bytes, or null + if no space is available. + free(Void_t* p); + Release the chunk of memory pointed to by p, or no effect if p is null. + realloc(Void_t* p, size_t n); + Return a pointer to a chunk of size n that contains the same data + as does chunk p up to the minimum of (n, p's size) bytes, or null + if no space is available. The returned pointer may or may not be + the same as p. If p is null, equivalent to malloc. Unless the + #define REALLOC_ZERO_BYTES_FREES below is set, realloc with a + size argument of zero (re)allocates a minimum-sized chunk. + memalign(size_t alignment, size_t n); + Return a pointer to a newly allocated chunk of n bytes, aligned + in accord with the alignment argument, which must be a power of + two. + valloc(size_t n); + Equivalent to memalign(pagesize, n), where pagesize is the page + size of the system (or as near to this as can be figured out from + all the includes/defines below.) + pvalloc(size_t n); + Equivalent to valloc(minimum-page-that-holds(n)), that is, + round up n to nearest pagesize. + calloc(size_t unit, size_t quantity); + Returns a pointer to quantity * unit bytes, with all locations + set to zero. + cfree(Void_t* p); + Equivalent to free(p). + malloc_trim(size_t pad); + Release all but pad bytes of freed top-most memory back + to the system. Return 1 if successful, else 0. + malloc_usable_size(Void_t* p); + Report the number usable allocated bytes associated with allocated + chunk p. This may or may not report more bytes than were requested, + due to alignment and minimum size constraints. + malloc_stats(); + Prints brief summary statistics on stderr. + mallinfo() + Returns (by copy) a struct containing various summary statistics. + mallopt(int parameter_number, int parameter_value) + Changes one of the tunable parameters described below. Returns + 1 if successful in changing the parameter, else 0. + +* Vital statistics: + + Assumed pointer representation: 4 or 8 bytes + (Thanks to Wolfram Gloger for contributing most of the + changes supporting dual 4/8.) + + Assumed size_t representation: 4 or 8 bytes + Note that size_t is allowed to be 4 bytes even if pointers are 8. + You can adjust this by defining INTERNAL_SIZE_T + + Alignment: 2 * sizeof(size_t) + (i.e., 8 byte alignment with 4byte size_t). This suffices for + nearly all current machines and C compilers. However, you can + define MALLOC_ALIGNMENT to be wider than this if necessary. + + Minimum overhead per allocated chunk: 4 or 8 bytes + Each malloced chunk has a hidden word of overhead holding size + and status information. + + Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead) + 8-byte ptrs: 24/32 bytes (including, 4/8 overhead) + + When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte + ptrs but 4 byte size) or 24 (for 8/8) additional bytes are + needed; 4 (8) for a trailing size field and 8 (16) bytes for + free list pointers. Thus, the minimum allocatable size is + 16/24/32 bytes. + + Even a request for zero bytes (i.e., malloc(0)) returns a + pointer to something of the minimum allocatable size. + + The maximum overhead wastage (i.e., number of extra bytes + allocated than were requested in malloc) is less than or equal + to the minimum size, except for requests >= mmap_threshold that + are serviced via mmap(), where the worst case wastage is 2 * + sizeof(size_t) bytes plus the remainder from a system page (the + minimal mmap unit); typically 4096 bytes. + + Maximum allocated size: 4-byte size_t: 2^31 minus about two pages + 8-byte size_t: 2^63 minus about two pages + + It is assumed that (possibly signed) size_t values suffice + to represent chunk sizes. `Possibly signed' is due to the fact + that `size_t' may be defined on a system as either a signed or + an unsigned type. The ISO C standard says that it must be + unsigned, but a few systems are known not to adhere to this. + Additionally, even when size_t is unsigned, sbrk (which is by + default used to obtain memory from system) accepts signed + arguments, and may not be able to handle size_t-wide arguments + with negative sign bit. To be conservative, values that would + appear as negative after accounting for overhead and alignment + are rejected. + + Requests for sizes outside this range will perform an optional + failure action and then return null. (Requests may also + also fail because a system is out of memory.) + + Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined + + When USE_MALLOC_LOCK is defined, wrappers are created to + surround every public call with either a pthread mutex or + a win32 critical section (depending on WIN32). This is not + especially fast, and can be a major bottleneck in programs with + many threads. It is designed only to provide minimal protection + in concurrent environments, and to provide a basis for + extensions. If you are using malloc in a concurrent program, + you would be far better off obtaining ptmalloc, which is + derived from a version of this malloc, and is well-tuned for + concurrent programs. (See http://www.malloc.de) + + Compliance: I believe it is compliant with the 1997 Single Unix Specification + + (See http://www.opennc.org). Probably other standards as well. + +* Limitations + + Here are some features that are NOT currently supported + + * No automated mechanism for fully checking that all accesses + to malloced memory stay within their bounds. However, there + are several add-ons and adaptations of this or other mallocs + available that do this. + * No support for compaction. + +* Synopsis of compile-time options: + + People have reported using previous versions of this malloc on all + versions of Unix, sometimes by tweaking some of the defines + below. It has been tested most extensively on Solaris and + Linux. It is also reported to work on WIN32 platforms. + People also report using it in stand-alone embedded systems. + + The implementation is in straight, hand-tuned ANSI C. It is not + at all modular. (Sorry!) It uses a lot of macros. To be at all + usable, this code should be compiled using an optimizing compiler + (for example gcc -O3) that can simplify expressions and control + paths. (FAQ: some macros import variables as arguments rather than + declare locals because people reported that some debuggers + otherwise get confused.) + + OPTION DEFAULT VALUE + + Compilation Environment options: + + __STD_C derived from C compiler defines + WIN32 NOT defined + HAVE_MEMCPY defined + USE_MEMCPY 1 if HAVE_MEMCPY is defined + HAVE_MMAP defined as 1 + MMAP_AS_MORECORE_SIZE (1024 * 1024) + HAVE_MREMAP defined as 0 unless linux defined + malloc_getpagesize derived from system #includes, or 4096 if not + HAVE_USR_INCLUDE_MALLOC_H NOT defined + LACKS_UNISTD_H NOT defined unless WIN32 + LACKS_SYS_PARAM_H NOT defined unless WIN32 + LACKS_SYS_MMAN_H NOT defined unless WIN32 + + Changing default word sizes: + + INTERNAL_SIZE_T size_t + MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T) + + Configuration and functionality options: + + USE_DL_PREFIX NOT defined + USE_PUBLIC_MALLOC_WRAPPERS NOT defined + USE_MALLOC_LOCK NOT defined + DEBUG NOT defined + REALLOC_ZERO_BYTES_FREES NOT defined + MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op + TRIM_FASTBINS 0 + + Options for customizing MORECORE: + + MORECORE sbrk + MORECORE_CONTIGUOUS 1 + + Tuning options that are also dynamically changeable via mallopt: + + DEFAULT_MXFAST 64 + DEFAULT_TRIM_THRESHOLD 128 * 1024 + DEFAULT_TOP_PAD 0 + DEFAULT_MMAP_THRESHOLD 128 * 1024 + DEFAULT_MMAP_MAX 256 + + There are several other #defined constants and macros that you + probably don't want to touch unless you are extending or adapting malloc. + +*/ +#include "xpcom-private.h" + + + +/* + WIN32 sets up defaults for MS environment and compilers. + Otherwise defaults are for unix. +*/ + +/* #define WIN32 */ + +#ifdef WIN32 + +#include <windows.h> + +/* Win32 doesn't supply or need the following headers */ +#define LACKS_UNISTD_H +#define LACKS_SYS_PARAM_H +#define LACKS_SYS_MMAN_H + +/* Use the supplied emulation of sbrk */ +#define MORECORE sbrk +#define MORECORE_CONTIGUOUS 1 +#define MORECORE_FAILURE ((void*)(-1)) + +/* Use the supplied emulation mmap, munmap */ +#define HAVE_MMAP 1 +#define MUNMAP_FAILURE (-1) +/* These values don't really matter in windows mmap emulation */ +#define MAP_PRIVATE 1 +#define MAP_ANONYMOUS 2 +#define PROT_READ 1 +#define PROT_WRITE 2 + +/* Emulation functions defined at the end of this file */ + +/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */ +#ifdef USE_MALLOC_LOCK +static int slwait(int *sl); +static int slrelease(int *sl); +#endif + +static long getpagesize(void); +static long getregionsize(void); +static void *sbrk(long size); +static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg); +static long munmap(void *ptr, long size); + +static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed); +static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user); + +#endif + + + +/* + __STD_C should be nonzero if using ANSI-standard C compiler, a C++ + compiler, or a C compiler sufficiently close to ANSI to get away + with it. +*/ + +#ifndef __STD_C +#ifdef __STDC__ +#define __STD_C 1 +#else +#if __cplusplus +#define __STD_C 1 +#else +#define __STD_C 0 +#endif /*__cplusplus*/ +#endif /*__STDC__*/ +#endif /*__STD_C*/ + + +/* + Void_t* is the pointer type that malloc should say it returns +*/ + +#ifndef Void_t +#if (__STD_C || defined(WIN32)) +#define Void_t void +#else +#define Void_t char +#endif +#endif /*Void_t*/ + +#if __STD_C +#include <stddef.h> /* for size_t */ +#else +#include <sys/types.h> +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */ + +/* #define LACKS_UNISTD_H */ + +#ifndef LACKS_UNISTD_H +#include <unistd.h> +#endif + +/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */ + +/* #define LACKS_SYS_PARAM_H */ + + +#include <stdio.h> /* needed for malloc_stats */ +#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */ + + +/* + Debugging: + + Because freed chunks may be overwritten with bookkeeping fields, this + malloc will often die when freed memory is overwritten by user + programs. This can be very effective (albeit in an annoying way) + in helping track down dangling pointers. + + If you compile with -DDEBUG, a number of assertion checks are + enabled that will catch more memory errors. You probably won't be + able to make much sense of the actual assertion errors, but they + should help you locate incorrectly overwritten memory. The + checking is fairly extensive, and will slow down execution + noticeably. Calling malloc_stats or mallinfo with DEBUG set will + attempt to check every non-mmapped allocated and free chunk in the + course of computing the summmaries. (By nature, mmapped regions + cannot be checked very much automatically.) + + Setting DEBUG may also be helpful if you are trying to modify + this code. The assertions in the check routines spell out in more + detail the assumptions and invariants underlying the algorithms. + +*/ + +#if DEBUG +#include <assert.h> +#else +#define assert(x) ((void)0) +#endif + + +/* + INTERNAL_SIZE_T is the word-size used for internal bookkeeping + of chunk sizes. + + The default version is the same as size_t. + + While not strictly necessary, it is best to define this as an + unsigned type, even if size_t is a signed type. This may avoid some + artificial size limitations on some systems. + + On a 64-bit machine, you may be able to reduce malloc overhead by + defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the + expense of not being able to handle more than 2^32 of malloced + space. If this limitation is acceptable, you are encouraged to set + this unless you are on a platform requiring 16byte alignments. In + this case the alignment requirements turn out to negate any + potential advantages of decreasing size_t word size. + + Note to implementors: To deal with all this, comparisons and + difference computations among INTERNAL_SIZE_Ts should normally cast + INTERNAL_SIZE_T's to long or unsigned long, as appropriate, being + aware of the fact that casting an unsigned int to a wider long does not + sign-extend. (This also makes checking for negative numbers awkward.) + +*/ + +#ifndef INTERNAL_SIZE_T +#define INTERNAL_SIZE_T size_t +#endif + +/* The corresponding word size */ +#define SIZE_SZ (sizeof(INTERNAL_SIZE_T)) + + +/* + MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks. + It must be a power of two at least 2 * SIZE_SZ, even on machines + for which smaller alignments would suffice. It may be defined as + larger than this though. (Note however that code and data structures + are optimized for the case of 8-byte alignment.) + +*/ + + /* #define MALLOC_ALIGNMENT 16 */ + +#ifndef MALLOC_ALIGNMENT +#define MALLOC_ALIGNMENT (2 * SIZE_SZ) +#endif + +/* The corresponding bit mask value */ +#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1) + + +/* + REALLOC_ZERO_BYTES_FREES should be set if a call to + realloc with zero bytes should be the same as a call to free. + Some people think it should. Otherwise, since this malloc + returns a unique pointer for malloc(0), so does realloc(p, 0). +*/ + +/* #define REALLOC_ZERO_BYTES_FREES */ + + +/* + USE_DL_PREFIX will prefix all public routines with the string 'dl'. + This is necessary when you only want to use this malloc in one part + of a program, using your regular system malloc elsewhere. +*/ + +/* #define USE_DL_PREFIX */ + + +/* + USE_MALLOC_LOCK causes wrapper functions to surround each + callable routine with pthread mutex lock/unlock. + + USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined +*/ + +/* #define USE_MALLOC_LOCK */ + + +/* + If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is + actually a wrapper function that first calls MALLOC_PREACTION, then + calls the internal routine, and follows it with + MALLOC_POSTACTION. This is needed for locking, but you can also use + this, without USE_MALLOC_LOCK, for purposes of interception, + instrumentation, etc. It is a sad fact that using wrappers often + noticeably degrades performance of malloc-intensive programs. +*/ + +#ifdef USE_MALLOC_LOCK +#define USE_PUBLIC_MALLOC_WRAPPERS +#else +/* #define USE_PUBLIC_MALLOC_WRAPPERS */ +#endif + + + + +/* + HAVE_MEMCPY should be defined if you are not otherwise using + ANSI STD C, but still have memcpy and memset in your C library + and want to use them in calloc and realloc. Otherwise simple + macro versions are defined below. + + USE_MEMCPY should be defined as 1 if you actually want to + have memset and memcpy called. People report that the macro + versions are faster than libc versions on some systems. + + Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks + (of <= 36 bytes) are manually unrolled in realloc and calloc. +*/ + +#define HAVE_MEMCPY + +#ifndef USE_MEMCPY +#ifdef HAVE_MEMCPY +#define USE_MEMCPY 1 +#else +#define USE_MEMCPY 0 +#endif +#endif + + +#if (__STD_C || defined(HAVE_MEMCPY)) + +#ifdef WIN32 + /* + On Win32 platforms, 'memset()' and 'memcpy()' are already declared in + 'windows.h' + */ +#else +#if __STD_C +void* memset(void*, int, size_t); +void* memcpy(void*, const void*, size_t); +void* memmove(void*, const void*, size_t); +#else +Void_t* memset(); +Void_t* memcpy(); +Void_t* memmove(); +#endif +#endif +#endif + + +/* + MALLOC_FAILURE_ACTION is the action to take before "return 0" when + malloc fails to be able to return memory, either because memory is + exhausted or because of illegal arguments. + + By default, sets errno if running on STD_C platform, else does nothing. +*/ + +#ifndef MALLOC_FAILURE_ACTION +#if __STD_C +#define MALLOC_FAILURE_ACTION \ + errno = ENOMEM; + +#else + +#define MALLOC_FAILURE_ACTION +#endif +#endif + +/* + Define HAVE_MMAP as true to optionally make malloc() use mmap() to + allocate very large blocks. These will be returned to the + operating system immediately after a free(). Also, if mmap + is available, it is used as a backup strategy in cases where + MORECORE fails to provide space from system. + + This malloc is best tuned to work with mmap for large requests. + If you do not have mmap, allocation of very large chunks (1MB + or so) may be slower than you'd like. +*/ + +#ifndef HAVE_MMAP +#define HAVE_MMAP 1 +#endif + +/* + MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if + sbrk fails, and mmap is used as a backup (which is done only if + HAVE_MMAP). The value must be a multiple of page size. This + backup strategy generally applies only when systems have "holes" in + address space, so sbrk cannot perform contiguous expansion, but + there is still space available on system. On systems for which + this is known to be useful (i.e. most linux kernels), this occurs + only when programs allocate huge amounts of memory. Between this, + and the fact that mmap regions tend to be limited, the size should + be large, to avoid too many mmap calls and thus avoid running out + of kernel resources. +*/ + +#ifndef MMAP_AS_MORECORE_SIZE +#define MMAP_AS_MORECORE_SIZE (1024 * 1024) +#endif + + + +/* + Define HAVE_MREMAP to make realloc() use mremap() to re-allocate + large blocks. This is currently only possible on Linux with + kernel versions newer than 1.3.77. +*/ + +#ifndef HAVE_MREMAP +#ifdef linux +#define HAVE_MREMAP 1 +#else +#define HAVE_MREMAP 0 +#endif + +#endif /* HAVE_MMAP */ + + +/* + + This version of malloc supports the standard SVID/XPG mallinfo + routine that returns a struct containing usage properties and + statistics. It should work on any SVID/XPG compliant system that has + a /usr/include/malloc.h defining struct mallinfo. (If you'd like to + install such a thing yourself, cut out the preliminary declarations + as described above and below and save them in a malloc.h file. But + there's no compelling reason to bother to do this.) + + The main declaration needed is the mallinfo struct that is returned + (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a + bunch of field that are not even meaningful in this version of + malloc. These fields are are instead filled by mallinfo() with + other numbers that might be of interest. + + HAVE_USR_INCLUDE_MALLOC_H should be set if you have a + /usr/include/malloc.h file that includes a declaration of struct + mallinfo. If so, it is included; else an SVID2/XPG2 compliant + version is declared below. These must be precisely the same for + mallinfo() to work. + +*/ + +/* #define HAVE_USR_INCLUDE_MALLOC_H */ + +#ifdef HAVE_USR_INCLUDE_MALLOC_H +#include "/usr/include/malloc.h" +#else + +/* SVID2/XPG mallinfo structure */ + +struct mallinfo { + int arena; /* non-mmapped space allocated from system */ + int ordblks; /* number of free chunks */ + int smblks; /* number of fastbin blocks */ + int hblks; /* number of mmapped regions */ + int hblkhd; /* space in mmapped regions */ + int usmblks; /* maximum total allocated space */ + int fsmblks; /* space available in freed fastbin blocks */ + int uordblks; /* total allocated space */ + int fordblks; /* total free space */ + int keepcost; /* top-most, releasable (via malloc_trim) space */ +}; + +/* SVID2/XPG mallopt options */ + +#define M_MXFAST 1 /* Set maximum fastbin size */ +#define M_NLBLKS 2 /* UNUSED in this malloc */ +#define M_GRAIN 3 /* UNUSED in this malloc */ +#define M_KEEP 4 /* UNUSED in this malloc */ + + +#endif + + +/* Additional mallopt options supported in this malloc */ + +#ifndef M_TRIM_THRESHOLD +#define M_TRIM_THRESHOLD -1 +#endif + +#ifndef M_TOP_PAD +#define M_TOP_PAD -2 +#endif + +#ifndef M_MMAP_THRESHOLD +#define M_MMAP_THRESHOLD -3 +#endif + +#ifndef M_MMAP_MAX +#define M_MMAP_MAX -4 +#endif + + +/* + MXFAST is the maximum request size used for "fastbins", special bins + that hold returned chunks without consolidating their spaces. This + enables future requests for chunks of the same size to be handled + very quickly, but can increase fragmentation, and thus increase the + overall memory footprint of a program. + + This malloc manages fastbins very conservatively yet still + efficiently, so fragmentation is rarely a problem for values less + than or equal to the default. The maximum supported value of MXFAST + is 80. You wouldn't want it any higher than this anyway. Fastbins + are designed especially for use with many small structs, objects or + strings -- the default handles structs/objects/arrays with sizes up + to 8 4byte fields, or small strings representing words, tokens, + etc. Using fastbins for larger objects normally worsens + fragmentation without improving speed. + + MXFAST is set in REQUEST size units. It is internally used in + chunksize units, which adds padding and alignment. You can reduce + MXFAST to 0 to disable all use of fastbins. This causes the malloc + algorithm to be a close approximation of fifo-best-fit in all cases, + not just for larger requests, but will generally cause it to be + slower. + +*/ + +#ifndef DEFAULT_MXFAST +#define DEFAULT_MXFAST 64 +#endif + + +/* + M_TRIM_THRESHOLD is the maximum amount of unused top-most memory + to keep before releasing via malloc_trim in free(). + + Automatic trimming is mainly useful in long-lived programs. + Because trimming via sbrk can be slow on some systems, and can + sometimes be wasteful (in cases where programs immediately + afterward allocate more large chunks) the value should be high + enough so that your overall system performance would improve by + releasing. + + The trim threshold and the mmap control parameters (see below) + can be traded off with one another. Trimming and mmapping are + two different ways of releasing unused memory back to the + system. Between these two, it is often possible to keep + system-level demands of a long-lived program down to a bare + minimum. For example, in one test suite of sessions measuring + the XF86 X server on Linux, using a trim threshold of 128K and a + mmap threshold of 192K led to near-minimal long term resource + consumption. + + If you are using this malloc in a long-lived program, it should + pay to experiment with these values. As a rough guide, you + might set to a value close to the average size of a process + (program) running on your system. Releasing this much memory + would allow such a process to run in memory. Generally, it's + worth it to tune for trimming rather tham memory mapping when a + program undergoes phases where several large chunks are + allocated and released in ways that can reuse each other's + storage, perhaps mixed with phases where there are no such + chunks at all. And in well-behaved long-lived programs, + controlling release of large blocks via trimming versus mapping + is usually faster. + + However, in most programs, these parameters serve mainly as + protection against the system-level effects of carrying around + massive amounts of unneeded memory. Since frequent calls to + sbrk, mmap, and munmap otherwise degrade performance, the default + parameters are set to relatively high values that serve only as + safeguards. + + The default trim value is high enough to cause trimming only in + fairly extreme (by current memory consumption standards) cases. + It must be greater than page size to have any useful effect. To + disable trimming completely, you can set to (unsigned long)(-1); + + Trim settings interact with fastbin (MXFAST) settings: Unless + TRIM_FASTBINS is defined, automatic trimming never takes place upon + freeing a chunk with size less than or equal to MXFAST. Trimming is + instead delayed until subsequent freeing of larger chunks. However, + you can still force an attempted trim by calling malloc_trim. + + Also, trimming is not generally possible in cases where + the main arena is obtained via mmap. + +*/ + + +#ifndef DEFAULT_TRIM_THRESHOLD +#define DEFAULT_TRIM_THRESHOLD (128 * 1024) +#endif + + + +/* + M_TOP_PAD is the amount of extra `padding' space to allocate or + retain whenever sbrk is called. It is used in two ways internally: + + * When sbrk is called to extend the top of the arena to satisfy + a new malloc request, this much padding is added to the sbrk + request. + + * When malloc_trim is called automatically from free(), + it is used as the `pad' argument. + + In both cases, the actual amount of padding is rounded + so that the end of the arena is always a system page boundary. + + The main reason for using padding is to avoid calling sbrk so + often. Having even a small pad greatly reduces the likelihood + that nearly every malloc request during program start-up (or + after trimming) will invoke sbrk, which needlessly wastes + time. + + Automatic rounding-up to page-size units is normally sufficient + to avoid measurable overhead, so the default is 0. However, in + systems where sbrk is relatively slow, it can pay to increase + this value, at the expense of carrying around more memory than + the program needs. + +*/ + +#ifndef DEFAULT_TOP_PAD +#define DEFAULT_TOP_PAD (0) +#endif + +/* + + M_MMAP_THRESHOLD is the request size threshold for using mmap() + to service a request. Requests of at least this size that cannot + be allocated using already-existing space will be serviced via mmap. + (If enough normal freed space already exists it is used instead.) + + Using mmap segregates relatively large chunks of memory so that + they can be individually obtained and released from the host + system. A request serviced through mmap is never reused by any + other request (at least not directly; the system may just so + happen to remap successive requests to the same locations). + + Segregating space in this way has the benefit that mmapped space + can ALWAYS be individually released back to the system, which + helps keep the system level memory demands of a long-lived + program low. Mapped memory can never become `locked' between + other chunks, as can happen with normally allocated chunks, which + means that even trimming via malloc_trim would not release them. + + However, it has the disadvantages that: + + 1. The space cannot be reclaimed, consolidated, and then + used to service later requests, as happens with normal chunks. + 2. It can lead to more wastage because of mmap page alignment + requirements + 3. It causes malloc performance to be more dependent on host + system memory management support routines which may vary in + implementation quality and may impose arbitrary + limitations. Generally, servicing a request via normal + malloc steps is faster than going through a system's mmap. + + All together, these considerations should lead you to use mmap + only for relatively large requests. + +*/ + + +#ifndef DEFAULT_MMAP_THRESHOLD +#define DEFAULT_MMAP_THRESHOLD (128 * 1024) +#endif + +/* + M_MMAP_MAX is the maximum number of requests to simultaneously + service using mmap. This parameter exists because: + + 1. Some systems have a limited number of internal tables for + use by mmap. + 2. In most systems, overreliance on mmap can degrade overall + performance. + 3. If a program allocates many large regions, it is probably + better off using normal sbrk-based allocation routines that + can reclaim and reallocate normal heap memory. + + Setting to 0 disables use of mmap for servicing large requests. If + HAVE_MMAP is not set, the default value is 0, and attempts to set it + to non-zero values in mallopt will fail. +*/ + + + +#ifndef DEFAULT_MMAP_MAX +#if HAVE_MMAP +#define DEFAULT_MMAP_MAX (256) +#else +#define DEFAULT_MMAP_MAX (0) +#endif +#endif + + +/* + TRIM_FASTBINS controls whether free() of a very small chunk can + immediately lead to trimming. Setting to true (1) can reduce memory + footprint, but will almost always slow down (by a few percent) + programs that use a lot of small chunks. + + Define this only if you are willing to give up some speed to more + aggressively reduce system-level memory footprint when releasing + memory in programs that use many small chunks. You can get + essentially the same effect by setting MXFAST to 0, but this can + lead to even greater slowdowns in programs using many small chunks. + TRIM_FASTBINS is an in-between compile-time option, that disables + only those chunks bordering topmost memory from being placed in + fastbins. + +*/ + + +#ifndef TRIM_FASTBINS +#define TRIM_FASTBINS 0 +#endif + + +/* + MORECORE-related declarations. By default, rely on sbrk +*/ + + +#ifdef LACKS_UNISTD_H +#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) +#if __STD_C +extern Void_t* sbrk(ptrdiff_t); +#else +extern Void_t* sbrk(); +#endif +#endif +#endif + +/* + MORECORE is the name of the routine to call to obtain more memory + from the system. See below for general guidance on writing + alternative MORECORE functions, as well as a version for WIN32 and a + sample version for pre-OSX macos. +*/ + +#ifndef MORECORE +#define MORECORE sbrk +#endif + + +/* + MORECORE_FAILURE is the value returned upon failure of MORECORE + as well as mmap. Since it cannot be an otherwise valid memory address, + and must reflect values of standard sys calls, you probably ought not + try to redefine it. +*/ + +#ifndef MORECORE_FAILURE +#define MORECORE_FAILURE (-1) +#endif + +/* + If MORECORE_CONTIGUOUS is true, take advantage of fact that + consecutive calls to MORECORE with positive arguments always return + contiguous increasing addresses. This is true of unix sbrk. Even + if not defined, when regions happen to be contiguous, malloc will + permit allocations spanning regions obtained from different + calls. But defining this when applicable enables some stronger + consistency checks and space efficiencies. +*/ + + +#ifndef MORECORE_CONTIGUOUS +#define MORECORE_CONTIGUOUS 1 +#endif + + +/* + The system page size. To the extent possible, this malloc manages + memory from the system in page-size units. Note that this value is + cached during initialization into a field of malloc_state. So even + if malloc_getpagesize is a function, it is only called once. + + The following mechanics for getpagesize were adapted from bsd/gnu + getpagesize.h. If none of the system-probes here apply, a value of + 4096 is used, which should be OK: If they don't apply, then using + the actual value probably doesn't impact performance. +*/ + +#ifndef malloc_getpagesize + +#ifndef LACKS_UNISTD_H +# include <unistd.h> +#endif + +# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */ +# ifndef _SC_PAGE_SIZE +# define _SC_PAGE_SIZE _SC_PAGESIZE +# endif +# endif + +# ifdef _SC_PAGE_SIZE +# define malloc_getpagesize sysconf(_SC_PAGE_SIZE) +# else +# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE) + extern size_t getpagesize(); +# define malloc_getpagesize getpagesize() +# else +# ifdef WIN32 /* use supplied emulation of getpagesize */ +# define malloc_getpagesize getpagesize() +# else +# ifndef LACKS_SYS_PARAM_H +# include <sys/param.h> +# endif +# ifdef EXEC_PAGESIZE +# define malloc_getpagesize EXEC_PAGESIZE +# else +# ifdef NBPG +# ifndef CLSIZE +# define malloc_getpagesize NBPG +# else +# define malloc_getpagesize (NBPG * CLSIZE) +# endif +# else +# ifdef NBPC +# define malloc_getpagesize NBPC +# else +# ifdef PAGESIZE +# define malloc_getpagesize PAGESIZE +# else /* just guess */ +# define malloc_getpagesize (4096) +# endif +# endif +# endif +# endif +# endif +# endif +# endif +#endif + + +/* Two-phase Name mangling */ + +#ifndef USE_PUBLIC_MALLOC_WRAPPERS +#define cALLOc public_cALLOc +#define fREe public_fREe +#define cFREe public_cFREe +#define mALLOc public_mALLOc +#define mEMALIGn public_mEMALIGn +#define rEALLOc public_rEALLOc +#define vALLOc public_vALLOc +#define pVALLOc public_pVALLOc +#define mALLINFo public_mALLINFo +#define mALLOPt public_mALLOPt +#define mTRIm public_mTRIm +#define mSTATs public_mSTATs +#define mUSABLe public_mUSABLe +#endif + +#ifdef USE_DL_PREFIX +#define public_cALLOc dlcalloc +#define public_fREe dlfree +#define public_cFREe dlcfree +#define public_mALLOc dlmalloc +#define public_mEMALIGn dlmemalign +#define public_rEALLOc dlrealloc +#define public_vALLOc dlvalloc +#define public_pVALLOc dlpvalloc +#define public_mALLINFo dlmallinfo +#define public_mALLOPt dlmallopt +#define public_mTRIm dlmalloc_trim +#define public_mSTATs dlmalloc_stats +#define public_mUSABLe dlmalloc_usable_size +#else /* USE_DL_PREFIX */ +#define public_cALLOc calloc +#define public_fREe free +#define public_cFREe cfree +#define public_mALLOc malloc +#define public_mEMALIGn memalign +#define public_rEALLOc realloc +#define public_vALLOc valloc +#define public_pVALLOc pvalloc +#define public_mALLINFo mallinfo +#define public_mALLOPt mallopt +#define public_mTRIm malloc_trim +#define public_mSTATs malloc_stats +#define public_mUSABLe malloc_usable_size +#endif /* USE_DL_PREFIX */ + +#if __STD_C + +Void_t* public_mALLOc(size_t); +void public_fREe(Void_t*); +Void_t* public_rEALLOc(Void_t*, size_t); +Void_t* public_mEMALIGn(size_t, size_t); +Void_t* public_vALLOc(size_t); +Void_t* public_pVALLOc(size_t); +Void_t* public_cALLOc(size_t, size_t); +void public_cFREe(Void_t*); +int public_mTRIm(size_t); +size_t public_mUSABLe(Void_t*); +void public_mSTATs(); +int public_mALLOPt(int, int); +struct mallinfo public_mALLINFo(void); +#else +Void_t* public_mALLOc(); +void public_fREe(); +Void_t* public_rEALLOc(); +Void_t* public_mEMALIGn(); +Void_t* public_vALLOc(); +Void_t* public_pVALLOc(); +Void_t* public_cALLOc(); +void public_cFREe(); +int public_mTRIm(); +size_t public_mUSABLe(); +void public_mSTATs(); +int public_mALLOPt(); +struct mallinfo public_mALLINFo(); +#endif + + +#ifdef __cplusplus +}; /* end of extern "C" */ +#endif + + + +/* ---------- To make a malloc.h, end cutting here ------------ */ + + +/* Declarations of internal utilities defined below */ + + + + +#ifdef USE_PUBLIC_MALLOC_WRAPPERS +#if __STD_C + +static Void_t* mALLOc(size_t); +static void fREe(Void_t*); +static Void_t* rEALLOc(Void_t*, size_t); +static Void_t* mEMALIGn(size_t, size_t); +static Void_t* vALLOc(size_t); +static Void_t* pVALLOc(size_t); +static Void_t* cALLOc(size_t, size_t); +static void cFREe(Void_t*); +static int mTRIm(size_t); +static size_t mUSABLe(Void_t*); +static void mSTATs(); +static int mALLOPt(int, int); +static struct mallinfo mALLINFo(void); +#else +static Void_t* mALLOc(); +static void fREe(); +static Void_t* rEALLOc(); +static Void_t* mEMALIGn(); +static Void_t* vALLOc(); +static Void_t* pVALLOc(); +static Void_t* cALLOc(); +static void cFREe(); +static int mTRIm(); +static size_t mUSABLe(); +static void mSTATs(); +static int mALLOPt(); +static struct mallinfo mALLINFo(); +#endif +#endif + + + +/* ---------- public wrappers --------------- */ + +#ifdef USE_PUBLIC_MALLOC_WRAPPERS + +/* + MALLOC_PREACTION and MALLOC_POSTACTION should be + defined to return 0 on success, and nonzero on failure. + The return value of MALLOC_POSTACTION is currently ignored + in wrapper functions since there is no reasonable default + action to take on failure. +*/ + + +#ifdef USE_MALLOC_LOCK + +#ifdef WIN32 + +static int mALLOC_MUTEx; + +#define MALLOC_PREACTION slwait(&mALLOC_MUTEx) +#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx) + +#else + +#include <pthread.h> + +static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER; + +#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx) +#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx) + +#endif /* USE_MALLOC_LOCK */ + +#else + +/* Substitute anything you like for these */ + +#define MALLOC_PREACTION (0) +#define MALLOC_POSTACTION (0) + +#endif + +Void_t* public_mALLOc(size_t bytes) { + Void_t* m; + if (MALLOC_PREACTION != 0) { + return 0; + } + m = mALLOc(bytes); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +void public_fREe(Void_t* m) { + if (MALLOC_PREACTION != 0) { + return; + } + fREe(m); + if (MALLOC_POSTACTION != 0) { + } +} + +Void_t* public_rEALLOc(Void_t* m, size_t bytes) { + if (MALLOC_PREACTION != 0) { + return 0; + } + m = rEALLOc(m, bytes); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +Void_t* public_mEMALIGn(size_t alignment, size_t bytes) { + Void_t* m; + if (MALLOC_PREACTION != 0) { + return 0; + } + m = mEMALIGn(alignment, bytes); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +Void_t* public_vALLOc(size_t bytes) { + Void_t* m; + if (MALLOC_PREACTION != 0) { + return 0; + } + m = vALLOc(bytes); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +Void_t* public_pVALLOc(size_t bytes) { + Void_t* m; + if (MALLOC_PREACTION != 0) { + return 0; + } + m = pVALLOc(bytes); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +Void_t* public_cALLOc(size_t n, size_t elem_size) { + Void_t* m; + if (MALLOC_PREACTION != 0) { + return 0; + } + m = cALLOc(n, elem_size); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +void public_cFREe(Void_t* m) { + if (MALLOC_PREACTION != 0) { + return; + } + cFREe(m); + if (MALLOC_POSTACTION != 0) { + } +} + +int public_mTRIm(size_t s) { + int result; + if (MALLOC_PREACTION != 0) { + return 0; + } + result = mTRIm(s); + if (MALLOC_POSTACTION != 0) { + } + return result; +} + + +size_t public_mUSABLe(Void_t* m) { + size_t result; + if (MALLOC_PREACTION != 0) { + return 0; + } + result = mUSABLe(m); + if (MALLOC_POSTACTION != 0) { + } + return result; +} + + +void public_mSTATs() { + if (MALLOC_PREACTION != 0) { + return; + } + mSTATs(); + if (MALLOC_POSTACTION != 0) { + } +} + +struct mallinfo public_mALLINFo() { + struct mallinfo m; + if (MALLOC_PREACTION != 0) { + return m; + } + m = mALLINFo(); + if (MALLOC_POSTACTION != 0) { + } + return m; +} + +int public_mALLOPt(int p, int v) { + int result; + if (MALLOC_PREACTION != 0) { + return 0; + } + result = mALLOPt(p, v); + if (MALLOC_POSTACTION != 0) { + } + return result; +} + +#endif + + + +/* ------------- Optional versions of memcopy ---------------- */ + + +#if USE_MEMCPY + +#define MALLOC_COPY(dest, src, nbytes, overlap) \ + ((overlap) ? memmove(dest, src, nbytes) : memcpy(dest, src, nbytes)) +#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes) + +#else /* !USE_MEMCPY */ + +/* Use Duff's device for good zeroing/copying performance. */ + +#define MALLOC_ZERO(charp, nbytes) \ +do { \ + INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \ + long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \ + if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \ + switch (mctmp) { \ + case 0: for(;;) { *mzp++ = 0; \ + case 7: *mzp++ = 0; \ + case 6: *mzp++ = 0; \ + case 5: *mzp++ = 0; \ + case 4: *mzp++ = 0; \ + case 3: *mzp++ = 0; \ + case 2: *mzp++ = 0; \ + case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \ + } \ +} while(0) + +/* For overlapping case, dest is always _below_ src. */ + +#define MALLOC_COPY(dest,src,nbytes,overlap) \ +do { \ + INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \ + INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \ + long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \ + if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \ + switch (mctmp) { \ + case 0: for(;;) { *mcdst++ = *mcsrc++; \ + case 7: *mcdst++ = *mcsrc++; \ + case 6: *mcdst++ = *mcsrc++; \ + case 5: *mcdst++ = *mcsrc++; \ + case 4: *mcdst++ = *mcsrc++; \ + case 3: *mcdst++ = *mcsrc++; \ + case 2: *mcdst++ = *mcsrc++; \ + case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \ + } \ +} while(0) + +#endif + +/* ------------------ MMAP support ------------------ */ + + +#if HAVE_MMAP + +#include <fcntl.h> +#ifndef LACKS_SYS_MMAN_H +#include <sys/mman.h> +#endif + +#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) +#define MAP_ANONYMOUS MAP_ANON +#endif + + +/* + Nearly all versions of mmap support MAP_ANONYMOUS, + so the following is unlikely to be needed, but is + supplied just in case. +*/ + +#ifndef MAP_ANONYMOUS + +static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */ + +#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \ + (dev_zero_fd = open("/dev/zero", O_RDWR), \ + mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \ + mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) + +#else + +#define MMAP(addr, size, prot, flags) \ + (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0)) + +#endif + +#endif /* HAVE_MMAP */ + + +/* ---------- Alternative MORECORE functions ------------ */ + + +/* + General Requirements for MORECORE. + + The MORECORE function must have the following properties: + + If MORECORE_CONTIGUOUS is false: + + * MORECORE must allocate in multiples of pagesize. It will + only be called with arguments that are multiples of pagesize. + + * MORECORE must page-align. That is, MORECORE(0) must + return an address at a page boundary. + + else (i.e. If MORECORE_CONTIGUOUS is true): + + * Consecutive calls to MORECORE with positive arguments + return increasing addresses, indicating that space has been + contiguously extended. + + * MORECORE need not allocate in multiples of pagesize. + Calls to MORECORE need not have args of multiples of pagesize. + + * MORECORE need not page-align. + + In either case: + + * MORECORE may allocate more memory than requested. (Or even less, + but this will generally result in a malloc failure.) + + * MORECORE must not allocate memory when given argument zero, but + instead return one past the end address of memory from previous + nonzero call. This malloc does NOT call MORECORE(0) + until at least one call with positive arguments is made, so + the initial value returned is not important. + + * Even though consecutive calls to MORECORE need not return contiguous + addresses, it must be OK for malloc'ed chunks to span multiple + regions in those cases where they do happen to be contiguous. + + * MORECORE need not handle negative arguments -- it may instead + just return MORECORE_FAILURE when given negative arguments. + Negative arguments are always multiples of pagesize. MORECORE + must not misinterpret negative args as large positive unsigned + args. + + There is some variation across systems about the type of the + argument to sbrk/MORECORE. If size_t is unsigned, then it cannot + actually be size_t, because sbrk supports negative args, so it is + normally the signed type of the same width as size_t (sometimes + declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much + matter though. Internally, we use "long" as arguments, which should + work across all reasonable possibilities. + + Additionally, if MORECORE ever returns failure for a positive + request, and HAVE_MMAP is true, then mmap is used as a noncontiguous + system allocator. This is a useful backup strategy for systems with + holes in address spaces -- in this case sbrk cannot contiguously + expand the heap, but mmap may be able to map noncontiguous space. + If you'd like mmap to ALWAYS be used, you can define MORECORE to be + a function that always returns MORECORE_FAILURE. + + If you are using this malloc with something other than unix sbrk to + supply memory regions, you probably want to set MORECORE_CONTIGUOUS + as false. As an example, here is a custom allocator kindly + contributed for pre-OSX macOS. It uses virtually but not + necessarily physically contiguous non-paged memory (locked in, + present and won't get swapped out). You can use it by uncommenting + this section, adding some #includes, and setting up the appropriate + defines above: + + #define MORECORE osMoreCore + #define MORECORE_CONTIGUOUS 0 + + There is also a shutdown routine that should somehow be called for + cleanup upon program exit. + + #define MAX_POOL_ENTRIES 100 + #define MINIMUM_MORECORE_SIZE (64 * 1024) + static int next_os_pool; + void *our_os_pools[MAX_POOL_ENTRIES]; + + void *osMoreCore(int size) + { + void *ptr = 0; + static void *sbrk_top = 0; + + if (size > 0) + { + if (size < MINIMUM_MORECORE_SIZE) + size = MINIMUM_MORECORE_SIZE; + if (CurrentExecutionLevel() == kTaskLevel) + ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0); + if (ptr == 0) + { + return (void *) MORECORE_FAILURE; + } + // save ptrs so they can be freed during cleanup + our_os_pools[next_os_pool] = ptr; + next_os_pool++; + ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK); + sbrk_top = (char *) ptr + size; + return ptr; + } + else if (size < 0) + { + // we don't currently support shrink behavior + return (void *) MORECORE_FAILURE; + } + else + { + return sbrk_top; + } + } + + // cleanup any allocated memory pools + // called as last thing before shutting down driver + + void osCleanupMem(void) + { + void **ptr; + + for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++) + if (*ptr) + { + PoolDeallocate(*ptr); + *ptr = 0; + } + } + +*/ + + + + + +/* + ----------------------- Chunk representations ----------------------- +*/ + + +/* + This struct declaration is misleading (but accurate and necessary). + It declares a "view" into memory allowing access to necessary + fields at known offsets from a given base. See explanation below. +*/ + +struct malloc_chunk { + + INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */ + INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */ + + struct malloc_chunk* fd; /* double links -- used only if free. */ + struct malloc_chunk* bk; +}; + + +typedef struct malloc_chunk* mchunkptr; + +/* + + malloc_chunk details: + + (The following includes lightly edited explanations by Colin Plumb.) + + Chunks of memory are maintained using a `boundary tag' method as + described in e.g., Knuth or Standish. (See the paper by Paul + Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a + survey of such techniques.) Sizes of free chunks are stored both + in the front of each chunk and at the end. This makes + consolidating fragmented chunks into bigger chunks very fast. The + size fields also hold bits representing whether chunks are free or + in use. + + An allocated chunk looks like this: + + + chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of previous chunk, if allocated | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of chunk, in bytes |P| + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | User data starts here... . + . . + . (malloc_usable_space() bytes) . + . | +nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of chunk | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + + Where "chunk" is the front of the chunk for the purpose of most of + the malloc code, but "mem" is the pointer that is returned to the + user. "Nextchunk" is the beginning of the next contiguous chunk. + + Chunks always begin on even word boundries, so the mem portion + (which is returned to the user) is also on an even word boundary, and + thus double-word aligned. + + Free chunks are stored in circular doubly-linked lists, and look like this: + + chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Size of previous chunk | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + `head:' | Size of chunk, in bytes |P| + mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Forward pointer to next chunk in list | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Back pointer to previous chunk in list | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Unused space (may be 0 bytes long) . + . . + . | +nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + `foot:' | Size of chunk, in bytes | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + The P (PREV_INUSE) bit, stored in the unused low-order bit of the + chunk size (which is always a multiple of two words), is an in-use + bit for the *previous* chunk. If that bit is *clear*, then the + word before the current chunk size contains the previous chunk + size, and can be used to find the front of the previous chunk. + The very first chunk allocated always has this bit set, + preventing access to non-existent (or non-owned) memory. If + prev_inuse is set for any given chunk, then you CANNOT determine + the size of the previous chunk, and might even get a memory + addressing fault when trying to do so. + + Note that the `foot' of the current chunk is actually represented + as the prev_size of the NEXT chunk. (This makes it easier to + deal with alignments etc). + + The two exceptions to all this are + + 1. The special chunk `top' doesn't bother using the + trailing size field since there is no next contiguous chunk + that would have to index off it. After initialization, `top' + is forced to always exist. If it would become less than + MINSIZE bytes long, it is replenished. + + 2. Chunks allocated via mmap, which have the second-lowest-order + bit (IS_MMAPPED) set in their size fields. Because they are + allocated one-by-one, each must contain its own trailing size field. + +*/ + + + +/* + Size and alignment checks and conversions +*/ + +/* conversion from malloc headers to user pointers, and back */ + +#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ)) +#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ)) + +/* The smallest possible chunk */ +#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk)) + +/* The smallest size we can malloc is an aligned minimal chunk */ + +#define MINSIZE ((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) + +/* Check if m has acceptable alignment */ + +#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0) + +/* + Check for negative/huge sizes. + This cannot just test for < 0 because argument might + be an unsigned type of uncertain width. +*/ + +#define IS_NEGATIVE(x) \ + ((unsigned long)x >= \ + (unsigned long)((((INTERNAL_SIZE_T)(1)) << ((SIZE_SZ)*8 - 1)))) + + +/* pad request bytes into a usable size -- internal version */ + +#define request2size(req) \ + (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \ + MINSIZE : \ + ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) + + +/* + Same, except check for negative/huge arguments. + This lets through args that are positive but wrap into + negatives when padded. However, these are trapped + elsewhere. +*/ + +#define checked_request2size(req, sz) \ + if (IS_NEGATIVE(req)) { \ + MALLOC_FAILURE_ACTION; \ + return 0; \ + } \ + (sz) = request2size(req); + + + + +/* + Physical chunk operations +*/ + + +/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */ + +#define PREV_INUSE 0x1 + + +/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */ + +#define IS_MMAPPED 0x2 + + +/* Bits to mask off when extracting size */ + +#define SIZE_BITS (PREV_INUSE|IS_MMAPPED) + + +/* Ptr to next physical malloc_chunk. */ + +#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) )) + + +/* Ptr to previous physical malloc_chunk */ + +#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) )) + + +/* Treat space at ptr + offset as a chunk */ + +#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s))) + + + + +/* + Dealing with use bits + + Note: IS_MMAPPED is intentionally not masked off from size field in + macros for which mmapped chunks should never be seen. This should + cause helpful core dumps to occur if it is tried by accident by + people extending or adapting this malloc. + +*/ + + +/* extract p's inuse bit */ + +#define inuse(p)\ +((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE) + + +/* extract inuse bit of previous chunk */ + +#define prev_inuse(p) ((p)->size & PREV_INUSE) + + +/* check for mmap()'ed chunk */ + +#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED) + + +/* set/clear chunk as being inuse without otherwise disturbing */ + +#define set_inuse(p)\ +((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE + +#define clear_inuse(p)\ +((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE) + + +/* check/set/clear inuse bits in known places */ + +#define inuse_bit_at_offset(p, s)\ + (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE) + +#define set_inuse_bit_at_offset(p, s)\ + (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE) + +#define clear_inuse_bit_at_offset(p, s)\ + (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE)) + + + + +/* + Dealing with size fields +*/ + +/* Get size, ignoring use bits */ + +#define chunksize(p) ((p)->size & ~(SIZE_BITS)) + +/* Set size at head, without disturbing its use bit */ + +#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s))) + +/* Set size/use field */ + +#define set_head(p, s) ((p)->size = (s)) + +/* Set size at footer (only when chunk is not in use) */ + +#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s)) + + + + + +/* + ------------------ Internal data structures -------------------- + + All internal state is held in an instance of malloc_state defined + below. There are no other static variables, except in two optional + cases: + * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared + above. + * If HAVE_MMAP is true, but mmap doesn't support + MAP_ANONYMOUS, a dummy file descriptor for mmap. + + Beware of lots of tricks that minimize the total space + requirements. The result is a little over 1K bytes (for 4byte + pointers and size_t.) + +*/ + +/* + + Bins + + An array of bin headers for free chunks. Each bin is doubly + linked. The bins are approximately proportionally (log) spaced. + There are a lot of these bins (128). This may look excessive, but + works very well in practice. Most bins hold sizes that are + unusual as malloc request sizes, but are more usual for fragments + and consolidated sets of chunks, which is what these bins hold, so + they can be found quickly. All procedures maintain the invariant + that no consolidated chunk physically borders another one, so each + chunk in a list is known to be preceeded and followed by either + inuse chunks or the ends of memory. + + Chunks in bins are kept in size order, with ties going to the + approximately least recently used chunk. Ordering is irrelevant + for the small bins, which all contain the same-sized chunks, but + facilitates best-fit allocation for larger chunks. (These lists + are just sequential. Keeping them in order almost never requires + enough traversal to warrant using fancier ordered data + structures.) Chunks of the same size are linked with the most + recently freed at the front, and allocations are taken from the + back. This results in LRU (FIFO) allocation order, which tends + to give each chunk an equal opportunity to be consolidated with + adjacent freed chunks, resulting in larger free chunks and less + fragmentation. + + To simplify use in double-linked lists, each bin header acts + as a malloc_chunk. This avoids special-casing for headers. + But to conserve space and (mainly) improve locality, we allocate + only the fd/bk pointers of bins, and then use repositioning tricks + to treat these as the fields of a malloc_chunk*. +*/ + +typedef struct malloc_chunk* mbinptr; + +#define NBINS 128 + + +/* addressing -- note that bin_at(0) does not exist */ + +#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1))) + + +/* analog of ++bin */ + +#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1))) + + +/* Reminders about list directionality within bins */ + +#define first(b) ((b)->fd) +#define last(b) ((b)->bk) + +/* + Take a chunk off a bin list +*/ + +#define unlink(P, BK, FD) { \ + FD = P->fd; \ + BK = P->bk; \ + FD->bk = BK; \ + BK->fd = FD; \ +} + +/* + Indexing bins + + Bins for sizes < 512 bytes contain chunks of all the same size, spaced + 8 bytes apart. Larger bins are approximately logarithmically spaced: + + 64 bins of size 8 + 32 bins of size 64 + 16 bins of size 512 + 8 bins of size 4096 + 4 bins of size 32768 + 2 bins of size 262144 + 1 bin of size what's left + + There is actually a little bit of slop in the numbers in bin_index + for the sake of speed. This makes no difference elsewhere. + + The bins top out at around 1mb because we expect to service large + chunks via mmap. + +*/ + +/* The first NSMALLBIN bins (and fastbins) hold only one size */ +#define NSMALLBINS 64 +#define SMALLBIN_WIDTH 8 +#define MIN_LARGE_SIZE 512 + +#define in_smallbin_range(sz) ((sz) < MIN_LARGE_SIZE) + +#define smallbin_index(sz) (((unsigned)(sz)) >> 3) + +#define largebin_index(sz) \ +(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \ + ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \ + ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \ + ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \ + ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \ + 126) + +#define bin_index(sz) \ + ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz)) + + +/* + Unsorted chunks + + All remainders from chunk splits, as well as all returned chunks, + are first placed in the "unsorted" bin. They are then placed + in regular bins after malloc gives them ONE chance to be used before + binning. So, basically, the unsorted_chunks list acts as a queue, + with chunks being placed on it in free (and malloc_consolidate), + and taken off (to be either used or placed in bins) in malloc. + +*/ + + +/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */ + +#define unsorted_chunks(M) (bin_at(M, 1)) + + +/* + Top + + The top-most available chunk (i.e., the one bordering the end of + available memory) is treated specially. It is never included in + any bin, is used only if no other chunk is available, and is + released back to the system if it is very large (see + M_TRIM_THRESHOLD). `top' is never properly linked to its bin + since it is always handled specially. Because top initially + points to its own bin with initial zero size, thus forcing + extension on the first malloc request, we avoid having any special + code in malloc to check whether it even exists yet. But we still + need to do so when getting memory from system, so we make + initial_top treat the bin as a legal but unusable chunk during the + interval between initialization and the first call to + sYSMALLOc. (This is somewhat delicate, since it relies on + the 2 preceding words to be zero during this interval as well.) +*/ + + +/* Conveniently, the unsorted bin can be used as dummy top on first call */ +#define initial_top(M) (unsorted_chunks(M)) + +/* + Binmap + + To help compensate for the large number of bins, a one-level index + structure is used for bin-by-bin searching. `binmap' is a + bitvector recording whether bins are definitely empty so they can + be skipped over during during traversals. The bits are NOT always + cleared as soon as bins are empty, but instead only + when they are noticed to be empty during traversal in malloc. + +*/ + +/* Conservatively use 32 bits per map word, even if on 64bit system */ +#define BINMAPSHIFT 5 +#define BITSPERMAP (1U << BINMAPSHIFT) +#define BINMAPSIZE (NBINS / BITSPERMAP) + +#define idx2block(i) ((i) >> BINMAPSHIFT) +#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1)))) + +#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i)) +#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i))) +#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i)) + + +/* + Fastbins + + An array of lists holding recently freed small chunks. Fastbins + are not doubly linked. It is faster to single-link them, and + since chunks are never removed from the middles of these lists, + double linking is not necessary. + + Chunks in fastbins keep their inuse bit set, so they cannot + be consolidated with other free chunks. malloc_consolidate + releases all chunks in fastbins and consolidates them with + other free chunks. +*/ + +typedef struct malloc_chunk* mfastbinptr; + +/* offset 2 to use otherwise unindexable first 2 bins */ +#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2) + +/* The maximum fastbin request size we support */ +#define MAX_FAST_SIZE 80 + +#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1) + + + +/* + Flag bit held in max_fast indicating that there probably are some + fastbin chunks . It is set true on entering a chunk into any fastbin, + and cleared only in malloc_consolidate. + + The truth value is inverted so that have_fastchunks will be true + upon startup (since statics are zero-filled). +*/ + + +#define have_fastchunks(M) (((M)->max_fast & 1U) == 0) +#define clear_fastchunks(M) ((M)->max_fast |= 1U) +#define set_fastchunks(M) ((M)->max_fast &= ~1U) + +/* + Initialization value of max_fast. + Use impossibly small value if 0. + Value also has flag bit clear. +*/ +#define req2max_fast(s) (((((s) == 0)? SMALLBIN_WIDTH: request2size(s))) | 1U) + + +/* + NONCONTIGUOUS_REGIONS is a special value for sbrk_base indicating that + MORECORE does not return contiguous regions. In this case, we do not check + or assume that the address of each chunk is at least sbrk_base. Otherwise, + contiguity is exploited in merging together, when possible, results + from consecutive MORECORE calls. + + The possible values for sbrk_base are: + MORECORE_FAILURE: + MORECORE has not yet been called, but we expect contiguous space + NONCONTIGUOUS_REGIONS: + we don't expect or rely on contiguous space + any other legal address: + the first address returned by MORECORE when contiguous +*/ + +#define NONCONTIGUOUS_REGIONS ((char*)(-3)) + + +/* + ----------- Internal state representation and initialization ----------- +*/ + + +struct malloc_state { + + /* The maximum chunk size to be eligible for fastbin */ + INTERNAL_SIZE_T max_fast; /* low bit used as fastbin flag */ + + /* Base of the topmost chunk -- not otherwise kept in a bin */ + mchunkptr top; + + /* The remainder from the most recent split of a small request */ + mchunkptr last_remainder; + + /* Fastbins */ + mfastbinptr fastbins[NFASTBINS]; + + /* Normal bins packed as described above */ + mchunkptr bins[NBINS * 2]; + + /* Bitmap of bins */ + unsigned int binmap[BINMAPSIZE]; + + /* Tunable parameters */ + unsigned long trim_threshold; + INTERNAL_SIZE_T top_pad; + INTERNAL_SIZE_T mmap_threshold; + + /* Memory map support */ + int n_mmaps; + int n_mmaps_max; + int max_n_mmaps; + + /* Bookkeeping for sbrk */ + unsigned int pagesize; /* Cache malloc_getpagesize */ + char* sbrk_base; /* first address returned by sbrk, + or NONCONTIGUOUS_REGIONS */ + /* Statistics */ + + INTERNAL_SIZE_T mmapped_mem; + INTERNAL_SIZE_T sbrked_mem; + + INTERNAL_SIZE_T max_sbrked_mem; + INTERNAL_SIZE_T max_mmapped_mem; + INTERNAL_SIZE_T max_total_mem; +}; + +typedef struct malloc_state *mstate; + +/* + There is exactly one instance of this struct in this malloc. + + If you are adapting this malloc in a way that does NOT use a static + malloc_state, you MUST explicitly zero-fill it before using. This + malloc relies on the property that malloc_state is initialized to + all zeroes (as is true of C statics). + +*/ + +static struct malloc_state av_; /* never directly referenced */ + +/* + All uses of av_ are via get_malloc_state(). + This simplifies construction of multithreaded, etc extensions. + + At most one call to get_malloc_state is made per invocation of + the public versions of malloc, free, and all other routines + except realloc, valloc, and vpalloc. Also, it is called + in check* routines if DEBUG is set. +*/ + +#define get_malloc_state() (&(av_)) + +/* + Initialize a malloc_state struct. + + This is called only from within malloc_consolidate, which needs + be called in the same contexts anyway. It is never called directly + outside of malloc_consolidate because some optimizing compilers try + to inline it at all call points, which turns out not to be an + optimization at all. (Inlining it only in malloc_consolidate is fine though.) +*/ + +#if __STD_C +static void malloc_init_state(mstate av) +#else +static void malloc_init_state(av) mstate av; +#endif +{ + int i; + mbinptr bin; + + + /* Uncomment this if you are not using a static av */ + /* MALLOC_ZERO(av, sizeof(struct malloc_state); */ + + /* Establish circular links for normal bins */ + for (i = 1; i < NBINS; ++i) { + bin = bin_at(av,i); + bin->fd = bin->bk = bin; + } + + av->max_fast = req2max_fast(DEFAULT_MXFAST); + + av->top_pad = DEFAULT_TOP_PAD; + av->n_mmaps_max = DEFAULT_MMAP_MAX; + av->mmap_threshold = DEFAULT_MMAP_THRESHOLD; + +#if MORECORE_CONTIGUOUS + av->trim_threshold = DEFAULT_TRIM_THRESHOLD; + av->sbrk_base = (char*)MORECORE_FAILURE; +#else + av->trim_threshold = (unsigned long)(-1); + av->sbrk_base = NONCONTIGUOUS_REGIONS; +#endif + + av->top = initial_top(av); + av->pagesize = malloc_getpagesize; +} + +/* + Other internal utilities operating on mstates +*/ + +#if __STD_C +static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate); +static int sYSTRIm(size_t, mstate); +static void malloc_consolidate(mstate); +#else +static Void_t* sYSMALLOc(); +static int sYSTRIm(); +static void malloc_consolidate(); +#endif + + +/* + Debugging support + + These routines make a number of assertions about the states + of data structures that should be true at all times. If any + are not true, it's very likely that a user program has somehow + trashed memory. (It's also possible that there is a coding error + in malloc. In which case, please report it!) + +*/ + +#if ! DEBUG + +#define check_chunk(P) +#define check_free_chunk(P) +#define check_inuse_chunk(P) +#define check_remalloced_chunk(P,N) +#define check_malloced_chunk(P,N) +#define check_malloc_state() + +#else +#define check_chunk(P) do_check_chunk(P) +#define check_free_chunk(P) do_check_free_chunk(P) +#define check_inuse_chunk(P) do_check_inuse_chunk(P) +#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N) +#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N) +#define check_malloc_state() do_check_malloc_state() + + +/* + Properties of all chunks +*/ + +#if __STD_C +static void do_check_chunk(mchunkptr p) +#else +static void do_check_chunk(p) mchunkptr p; +#endif +{ + + mstate av = get_malloc_state(); + unsigned long sz = chunksize(p); + + if (!chunk_is_mmapped(p)) { + + /* Has legal address ... */ + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) { + assert(((char*)p) >= ((char*)(av->sbrk_base))); + } + + if (p != av->top) { + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) { + assert(((char*)p + sz) <= ((char*)(av->top))); + } + } + else { + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) { + assert(((char*)p + sz) <= ((char*)(av->sbrk_base) + av->sbrked_mem)); + } + /* top size is always at least MINSIZE */ + assert((long)(sz) >= (long)(MINSIZE)); + /* top predecessor always marked inuse */ + assert(prev_inuse(p)); + } + + } + else { +#if HAVE_MMAP + /* address is outside main heap */ + /* unless mmap has been used as sbrk backup */ + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) { + assert(! (((char*)p) >= ((char*)av->sbrk_base) && + ((char*)p) < ((char*)(av->sbrk_base) + av->sbrked_mem))); + } + /* chunk is page-aligned */ + assert(((p->prev_size + sz) & (av->pagesize-1)) == 0); + /* mem is aligned */ + assert(aligned_OK(chunk2mem(p))); +#else + /* force an appropriate assert violation if debug set */ + assert(!chunk_is_mmapped(p)); +#endif + } + +} + +/* + Properties of free chunks +*/ + + +#if __STD_C +static void do_check_free_chunk(mchunkptr p) +#else +static void do_check_free_chunk(p) mchunkptr p; +#endif +{ + mstate av = get_malloc_state(); + + INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE; + mchunkptr next = chunk_at_offset(p, sz); + + do_check_chunk(p); + + /* Chunk must claim to be free ... */ + assert(!inuse(p)); + assert (!chunk_is_mmapped(p)); + + /* Unless a special marker, must have OK fields */ + if ((unsigned long)sz >= (unsigned long)MINSIZE) + { + assert((sz & MALLOC_ALIGN_MASK) == 0); + assert(aligned_OK(chunk2mem(p))); + /* ... matching footer field */ + assert(next->prev_size == sz); + /* ... and is fully consolidated */ + assert(prev_inuse(p)); + assert (next == av->top || inuse(next)); + + /* ... and has minimally sane links */ + assert(p->fd->bk == p); + assert(p->bk->fd == p); + } + else /* markers are always of size SIZE_SZ */ + assert(sz == SIZE_SZ); +} + +/* + Properties of inuse chunks +*/ + + +#if __STD_C +static void do_check_inuse_chunk(mchunkptr p) +#else +static void do_check_inuse_chunk(p) mchunkptr p; +#endif +{ + mstate av = get_malloc_state(); + mchunkptr next; + do_check_chunk(p); + + if (chunk_is_mmapped(p)) + return; /* mmapped chunks have no next/prev */ + + /* Check whether it claims to be in use ... */ + assert(inuse(p)); + + next = next_chunk(p); + + /* ... and is surrounded by OK chunks. + Since more things can be checked with free chunks than inuse ones, + if an inuse chunk borders them and debug is on, it's worth doing them. + */ + if (!prev_inuse(p)) { + /* Note that we cannot even look at prev unless it is not inuse */ + mchunkptr prv = prev_chunk(p); + assert(next_chunk(prv) == p); + do_check_free_chunk(prv); + } + + if (next == av->top) { + assert(prev_inuse(next)); + assert(chunksize(next) >= MINSIZE); + } + else if (!inuse(next)) + do_check_free_chunk(next); + +} + +/* + Properties of chunks recycled from fastbins +*/ + +#if __STD_C +static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s) +#else +static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s; +#endif +{ + + INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE; + + do_check_inuse_chunk(p); + + /* Legal size ... */ + assert((sz & MALLOC_ALIGN_MASK) == 0); + assert((long)sz - (long)MINSIZE >= 0); + assert((long)sz - (long)s >= 0); + assert((long)sz - (long)(s + MINSIZE) < 0); + + /* ... and alignment */ + assert(aligned_OK(chunk2mem(p))); + +} + +/* + Properties of nonrecycled chunks at the point they are malloced +*/ + +#if __STD_C +static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s) +#else +static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s; +#endif +{ + /* same as recycled case ... */ + do_check_remalloced_chunk(p, s); + + /* + ... plus, must obey implementation invariant that prev_inuse is + always true of any allocated chunk; i.e., that each allocated + chunk borders either a previously allocated and still in-use + chunk, or the base of its memory arena. This is ensured + by making all allocations from the the `lowest' part of any found + chunk. This does not necessarily hold however for chunks + recycled via fastbins. + */ + + assert(prev_inuse(p)); +} + + +/* + Properties of malloc_state. + + This may be useful for debugging malloc, as well as detecting user + programmer errors that somehow write into malloc_state. +*/ + +static void do_check_malloc_state() +{ + mstate av = get_malloc_state(); + int i; + mchunkptr p; + mchunkptr q; + mbinptr b; + unsigned int biton; + int empty; + unsigned int idx; + INTERNAL_SIZE_T size; + unsigned long total = 0; + int max_fast_bin; + + + /* internal size_t must be no wider than pointer type */ + assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*)); + + /* alignment is a power of 2 */ + assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0); + + /* cannot run remaining checks until fully initialized */ + if (av->top == 0 || av->top == initial_top(av)) + return; + + /* pagesize is a power of 2 */ + assert((av->pagesize & (av->pagesize-1)) == 0); + + /* properties of fastbins */ + + /* max_fast is in allowed range */ + + assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE)); + + max_fast_bin = fastbin_index(av->max_fast); + + for (i = 0; i < NFASTBINS; ++i) { + p = av->fastbins[i]; + + /* all bins past max_fast are empty */ + if (i > max_fast_bin) + assert(p == 0); + + while (p != 0) { + /* each chunk claims to be inuse */ + do_check_inuse_chunk(p); + total += chunksize(p); + /* chunk belongs in this bin */ + assert(fastbin_index(chunksize(p)) == i); + p = p->fd; + } + } + + if (total != 0) + assert(have_fastchunks(av)); + + /* check normal bins */ + for (i = 1; i < NBINS; ++i) { + b = bin_at(av,i); + + /* binmap is accurate (except for bin 1 == unsorted_chunks) */ + if (i >= 2) { + biton = get_binmap(av,i); + empty = last(b) == b; + if (!biton) + assert(empty); + else if (!empty) + assert(biton); + } + + for (p = last(b); p != b; p = p->bk) { + /* each chunk claims to be free */ + do_check_free_chunk(p); + size = chunksize(p); + total += size; + if (i >= 2) { + /* chunk belongs in bin */ + idx = bin_index(size); + assert(idx == i); + /* lists are sorted */ + assert(p->bk == b || chunksize(p->bk) >= chunksize(p)); + } + /* chunk is followed by a legal chain of inuse chunks */ + for (q = next_chunk(p); + q != av->top && inuse(q) && (long)(chunksize(q)) >= (long)MINSIZE; + q = next_chunk(q)) + do_check_inuse_chunk(q); + + } + } + + /* top chunk is OK */ + check_chunk(av->top); + + /* sanity checks for statistics */ + + assert(total <= (unsigned long)(av->max_total_mem)); + assert(av->n_mmaps >= 0); + assert(av->n_mmaps <= av->n_mmaps_max); + assert(av->n_mmaps <= av->max_n_mmaps); + assert(av->max_n_mmaps <= av->n_mmaps_max); + + assert((unsigned long)(av->sbrked_mem) <= + (unsigned long)(av->max_sbrked_mem)); + + assert((unsigned long)(av->mmapped_mem) <= + (unsigned long)(av->max_mmapped_mem)); + + assert((unsigned long)(av->max_total_mem) >= + (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem)); + +} + + +#endif + + + + + +/* ----------- Routines dealing with system allocation -------------- */ + +/* + Handle malloc cases requiring more memory from system. + malloc relays to sYSMALLOc if it cannot allocate out of + existing memory. + + On entry, it is assumed that av->top does not have enough + space to service request for nb bytes, thus requiring more meory + from system. +*/ + +#if __STD_C +static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av) +#else +static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av; +#endif +{ + mchunkptr old_top; /* incoming value of av->top */ + INTERNAL_SIZE_T old_size; /* its size */ + char* old_end; /* its end address */ + + long size; /* arg to first MORECORE or mmap call */ + char* brk; /* return value from MORECORE */ + char* mm; /* return value from mmap call*/ + + long correction; /* arg to 2nd MORECORE call */ + char* snd_brk; /* 2nd return val */ + + INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */ + INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */ + char* aligned_brk; /* aligned offset into brk */ + + mchunkptr p; /* the allocated/returned chunk */ + mchunkptr remainder; /* remainder from allocation */ + long remainder_size; /* its size */ + + unsigned long sum; /* for updating stats */ + + size_t pagemask = av->pagesize - 1; + + /* + If have mmap, and the request size meets the mmap threshold, and + the system supports mmap, and there are few enough currently + allocated mmapped regions, and a call to mmap succeeds, try to + directly map this request rather than expanding top. + */ + +#if HAVE_MMAP + if ((unsigned long)nb >= (unsigned long)(av->mmap_threshold) && + (av->n_mmaps < av->n_mmaps_max)) { + + /* + Round up size to nearest page. For mmapped chunks, the overhead + is one SIZE_SZ unit larger than for normal chunks, because there + is no following chunk whose prev_size field could be used. + */ + size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask; + + mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE)); + + if (mm != (char*)(MORECORE_FAILURE)) { + + /* + The offset to the start of the mmapped region is stored + in the prev_size field of the chunk. This allows us to adjust + returned start address to meet alignment requirements here + and in memalign(), and still be able to compute proper + address argument for later munmap in free() and realloc(). + */ + + front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK; + if (front_misalign > 0) { + correction = MALLOC_ALIGNMENT - front_misalign; + p = (mchunkptr)(mm + correction); + p->prev_size = correction; + set_head(p, (size - correction) |IS_MMAPPED); + } + else { + p = (mchunkptr)mm; + set_head(p, size|IS_MMAPPED); + } + + check_chunk(p); + + /* update statistics */ + + if (++av->n_mmaps > av->max_n_mmaps) + av->max_n_mmaps = av->n_mmaps; + + sum = av->mmapped_mem += size; + if (sum > (unsigned long)(av->max_mmapped_mem)) + av->max_mmapped_mem = sum; + sum += av->sbrked_mem; + if (sum > (unsigned long)(av->max_total_mem)) + av->max_total_mem = sum; + + return chunk2mem(p); + } + } +#endif + + /* record incoming configuration of top */ + + old_top = av->top; + old_size = chunksize(old_top); + old_end = (char*)(chunk_at_offset(old_top, old_size)); + + brk = snd_brk = (char*)(MORECORE_FAILURE); + + /* + If not the first time through, we require old_size to be + at least MINSIZE and to have prev_inuse set. + */ + + assert(old_top == initial_top(av) || + ((unsigned long) (old_size) >= (unsigned long)(MINSIZE) && + prev_inuse(old_top))); + + + /* Request enough space for nb + pad + overhead */ + + size = nb + av->top_pad + MINSIZE; + + /* + If contiguous, we can subtract out existing space that we hope to + combine with new space. We add it back later only if + we don't actually get contiguous space. + */ + + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) + size -= old_size; + + /* + Round to a multiple of page size. + If MORECORE is not contiguous, this ensures that we only call it + with whole-page arguments. And if MORECORE is contiguous and + this is not first time through, this preserves page-alignment of + previous calls. Otherwise, we re-correct anyway to page-align below. + */ + + size = (size + pagemask) & ~pagemask; + + /* + Don't try to call MORECORE if argument is so big as to appear + negative. Note that since mmap takes size_t arg, it may succeed + below even if we cannot call MORECORE. + */ + + if (size > 0) + brk = (char*)(MORECORE(size)); + + /* + If have mmap, try using it as a backup when MORECORE fails. This + is worth doing on systems that have "holes" in address space, so + sbrk cannot extend to give contiguous space, but space is available + elsewhere. Note that we ignore mmap max count and threshold limits, + since there is no reason to artificially limit use here. + */ + +#if HAVE_MMAP + if (brk == (char*)(MORECORE_FAILURE)) { + + /* Cannot merge with old top, so add its size back in */ + + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) + size = (size + old_size + pagemask) & ~pagemask; + + /* If we are relying on mmap as backup, then use larger units */ + + if ((unsigned long)size < (unsigned long)MMAP_AS_MORECORE_SIZE) + size = MMAP_AS_MORECORE_SIZE; + + brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE)); + + if (brk != (char*)(MORECORE_FAILURE)) { + + /* We do not need, and cannot use, another sbrk call to find end */ + snd_brk = brk + size; + + /* + Record that we no longer have a contiguous sbrk region. + After the first time mmap is used as backup, we cannot + ever rely on contiguous space. + */ + av->sbrk_base = NONCONTIGUOUS_REGIONS; + } + } +#endif + + if (brk != (char*)(MORECORE_FAILURE)) { + + av->sbrked_mem += size; + + /* + If MORECORE extends previous space, we can likewise extend top size. + */ + + if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) { + set_head(old_top, (size + old_size) | PREV_INUSE); + } + + /* + Otherwise, make adjustments guided by the special values of + av->sbrk_base (MORECORE_FAILURE or NONCONTIGUOUS_REGIONS): + + * If the first time through or noncontiguous, we need to call sbrk + just to find out where the end of memory lies. + + * We need to ensure that all returned chunks from malloc will meet + MALLOC_ALIGNMENT + + * If there was an intervening foreign sbrk, we need to adjust sbrk + request size to account for fact that we will not be able to + combine new space with existing space in old_top. + + * Almost all systems internally allocate whole pages at a time, in + which case we might as well use the whole last page of request. + So we allocate enough more memory to hit a page boundary now, + which in turn causes future contiguous calls to page-align. + + */ + + else { + front_misalign = 0; + end_misalign = 0; + correction = 0; + aligned_brk = brk; + + /* handle contiguous cases */ + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) { + + /* Guarantee alignment of first new chunk made from this space */ + + front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK; + if (front_misalign > 0) { + + /* + Skip over some bytes to arrive at an aligned position. + We don't need to specially mark these wasted front bytes. + They will never be accessed anyway because + prev_inuse of av->top (and any chunk created from its start) + is always true after initialization. + */ + + correction = MALLOC_ALIGNMENT - front_misalign; + aligned_brk += correction; + } + + /* + If this isn't adjacent to a previous sbrk, then we will not + be able to merge with old_top space, so must add to 2nd request. + */ + + correction += old_size; + + /* Pad out to hit a page boundary */ + + end_misalign = (INTERNAL_SIZE_T)(brk + size + correction); + correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign; + + assert(correction >= 0); + + snd_brk = (char*)(MORECORE(correction)); + + /* + If can't allocate correction, try to at least find out current + brk. It might be enough to proceed without failing. + + Note that if second sbrk did NOT fail, we assume that space + is contiguous with first sbrk. This is a safe assumption unless + program is multithreaded but doesn't use locks and a foreign sbrk + occurred between our first and second calls. + */ + + if (snd_brk == (char*)(MORECORE_FAILURE)) { + correction = 0; + snd_brk = (char*)(MORECORE(0)); + } + } + + /* handle non-contiguous cases */ + else { + + /* MORECORE/mmap must correctly align etc */ + assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0); + + /* Find out current end of memory */ + if (snd_brk == (char*)(MORECORE_FAILURE)) { + snd_brk = (char*)(MORECORE(0)); + } + + /* This must lie on a page boundary */ + if (snd_brk != (char*)(MORECORE_FAILURE)) { + assert(((INTERNAL_SIZE_T)(snd_brk) & pagemask) == 0); + } + } + + /* Adjust top based on results of second sbrk */ + if (snd_brk != (char*)(MORECORE_FAILURE)) { + + av->top = (mchunkptr)aligned_brk; + set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE); + + av->sbrked_mem += correction; + + /* If first time through and contiguous, record base */ + if (old_top == initial_top(av)) { + if (av->sbrk_base == (char*)(MORECORE_FAILURE)) + av->sbrk_base = brk; + } + + /* + Otherwise, we either have a gap due to foreign sbrk or a + non-contiguous region. Insert a double fencepost at old_top + to prevent consolidation with space we don't own. These + fenceposts are artificial chunks that are marked as inuse + and are in any case too small to use. We need two to make + sizes and alignments work out. + */ + + else { + + /* + Shrink old_top to insert fenceposts, keeping size a + multiple of MALLOC_ALIGNMENT. + */ + old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK; + set_head(old_top, old_size | PREV_INUSE); + + /* + Note that the following assignments overwrite old_top when + old_size was previously MINSIZE. This is intentional. We + need the fencepost, even if old_top otherwise gets lost. + */ + chunk_at_offset(old_top, old_size )->size = + SIZE_SZ|PREV_INUSE; + + chunk_at_offset(old_top, old_size + SIZE_SZ)->size = + SIZE_SZ|PREV_INUSE; + + /* If possible, release the rest. */ + if (old_size >= MINSIZE) + fREe(chunk2mem(old_top)); + + } + } + } + + /* Update statistics */ + + sum = av->sbrked_mem; + if (sum > (unsigned long)(av->max_sbrked_mem)) + av->max_sbrked_mem = sum; + + sum += av->mmapped_mem; + if (sum > (unsigned long)(av->max_total_mem)) + av->max_total_mem = sum; + + check_malloc_state(); + + /* finally, do the allocation */ + + p = av->top; + size = chunksize(p); + remainder_size = (long)size - (long)nb; + + /* check that one of the above allocation paths succeeded */ + if (remainder_size >= (long)MINSIZE) { + remainder = chunk_at_offset(p, nb); + av->top = remainder; + set_head(p, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + + check_malloced_chunk(p, nb); + return chunk2mem(p); + } + } + + /* catch all failure paths */ + MALLOC_FAILURE_ACTION; + return 0; +} + + +/* + sYSTRIm is an inverse of sorts to sYSMALLOc. + It gives memory back to the system (via negative + arguments to sbrk) if there is unused memory at the `high' end of + the malloc pool. It is called automatically by free() + when top space exceeds the trim threshold. + returns 1 if it actually released any memory, else 0. +*/ + +#if __STD_C +static int sYSTRIm(size_t pad, mstate av) +#else +static int sYSTRIm(pad, av) size_t pad; mstate av; +#endif +{ + long top_size; /* Amount of top-most memory */ + long extra; /* Amount to release */ + long released; /* Amount actually released */ + char* current_brk; /* address returned by pre-check sbrk call */ + char* new_brk; /* address returned by post-check sbrk call */ + size_t pagesz; + + /* Don't bother trying if sbrk doesn't provide contiguous regions */ + if (av->sbrk_base != NONCONTIGUOUS_REGIONS) { + + pagesz = av->pagesize; + top_size = chunksize(av->top); + + /* Release in pagesize units, keeping at least one page */ + extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz; + + if (extra > 0) { + + /* + Only proceed if end of memory is where we last set it. + This avoids problems if there were foreign sbrk calls. + */ + current_brk = (char*)(MORECORE(0)); + if (current_brk == (char*)(av->top) + top_size) { + + /* + Attempt to release memory. We ignore return value, + and instead call again to find out where new end of memory is. + This avoids problems if first call releases less than we asked, + of if failure somehow altered brk value. (We could still + encounter problems if it altered brk in some very bad way, + but the only thing we can do is adjust anyway, which will cause + some downstream failure.) + */ + + MORECORE(-extra); + new_brk = (char*)(MORECORE(0)); + + if (new_brk != (char*)MORECORE_FAILURE) { + released = (long)(current_brk - new_brk); + + if (released != 0) { + /* Success. Adjust top. */ + av->sbrked_mem -= released; + set_head(av->top, (top_size - released) | PREV_INUSE); + check_malloc_state(); + return 1; + } + } + } + } + } + + return 0; +} + +/* ----------------------- Main public routines ----------------------- */ + + +/* + Malloc routine. See running comments for algorithm description. +*/ + +#if __STD_C +Void_t* mALLOc(size_t bytes) +#else + Void_t* mALLOc(bytes) size_t bytes; +#endif +{ + mstate av = get_malloc_state(); + + INTERNAL_SIZE_T nb; /* normalized request size */ + unsigned int idx; /* associated bin index */ + mbinptr bin; /* associated bin */ + mfastbinptr* fb; /* associated fastbin */ + + mchunkptr victim; /* inspected/selected chunk */ + INTERNAL_SIZE_T size; /* its size */ + int victim_index; /* its bin index */ + + mchunkptr remainder; /* remainder from a split */ + long remainder_size; /* its size */ + + unsigned int block; /* bit map traverser */ + unsigned int bit; /* bit map traverser */ + unsigned int map; /* current word of binmap */ + + mchunkptr fwd; /* misc temp for linking */ + mchunkptr bck; /* misc temp for linking */ + + + /* + Check request for legality and convert to internal form, nb. + This rejects negative arguments when size_t is treated as + signed. It also rejects arguments that are so large that the size + appears negative when aligned and padded. The converted form + adds SIZE_T bytes overhead plus possibly more to obtain necessary + alignment and/or to obtain a size of at least MINSIZE, the + smallest allocatable size. + */ + + checked_request2size(bytes, nb); + + /* + If the size qualifies as a fastbin, first check corresponding bin. + This code is safe to execute even if av not yet initialized, so we + can try it first, which saves some time on this fast path. + */ + + if (nb <= av->max_fast) { + fb = &(av->fastbins[(fastbin_index(nb))]); + if ( (victim = *fb) != 0) { + *fb = victim->fd; + check_remalloced_chunk(victim, nb); + return chunk2mem(victim); + } + } + + /* + If a small request, check regular bin. Since these "smallbins" + hold one size each, no searching within bins is necessary. + + (If a large request, we need to wait until unsorted chunks are + processed to find best fit. But for small ones, fits are exact + anyway, so we can check now, which is faster.) + */ + + if (in_smallbin_range(nb)) { + idx = smallbin_index(nb); + bin = bin_at(av,idx); + + if ( (victim = last(bin)) != bin) { + if (victim == 0) /* initialization check */ + malloc_consolidate(av); + else { + bck = victim->bk; + set_inuse_bit_at_offset(victim, nb); + bin->bk = bck; + bck->fd = bin; + + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + } + } + + /* + If a large request, consolidate fastbins before continuing. + While it might look excessive to kill all fastbins before + even seeing if there is space available, this avoids + fragmentation problems normally associated with fastbins. + Also, in practice, programs tend to have runs of either small or + large requests, but less often mixtures, so consolidation is not + usually invoked all that often. + */ + + else { + idx = largebin_index(nb); + if (have_fastchunks(av)) /* consolidation/initialization check */ + malloc_consolidate(av); + } + + + /* + Process recently freed or remaindered chunks, taking one only if + it is exact fit, or, if a small request, it is the remainder from + the most recent non-exact fit. Place other traversed chunks in + bins. Note that this step is the only place in any routine where + chunks are placed in bins. + + The outer loop here is needed because we might not realize until + near the end of malloc that we should have consolidated, so must + do so and retry. This happens at most once, and only when we would + otherwise need to expand memory to service a "small" request. + */ + + + for(;;) { + + while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) { + bck = victim->bk; + size = chunksize(victim); + + /* + If a small request, try to use last remainder if it is the + only chunk in unsorted bin. This helps promote locality for + runs of consecutive small requests. This is the only + exception to best-fit. + */ + + if (in_smallbin_range(nb) && + victim == av->last_remainder && + bck == unsorted_chunks(av) && + (remainder_size = (long)size - (long)nb) >= (long)MINSIZE) { + + /* split and reattach remainder */ + remainder = chunk_at_offset(victim, nb); + unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder; + av->last_remainder = remainder; + remainder->bk = remainder->fd = unsorted_chunks(av); + + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + set_foot(remainder, remainder_size); + + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + + /* remove from unsorted list */ + unsorted_chunks(av)->bk = bck; + bck->fd = unsorted_chunks(av); + + /* Take now instead of binning if exact fit */ + + if (size == nb) { + set_inuse_bit_at_offset(victim, size); + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + + /* place chunk in bin */ + + if (in_smallbin_range(size)) { + victim_index = smallbin_index(size); + bck = bin_at(av, victim_index); + fwd = bck->fd; + } + else { + victim_index = largebin_index(size); + bck = bin_at(av, victim_index); + fwd = bck->fd; + + /* maintain large bins in sorted order */ + if (fwd != bck) { + /* if smaller than smallest, bypass loop below */ + if ((unsigned long)size <= + (unsigned long)(chunksize(bck->bk))) { + fwd = bck; + bck = bck->bk; + } + else { + while (fwd != bck && + (unsigned long)size < (unsigned long)(chunksize(fwd))) { + fwd = fwd->fd; + } + bck = fwd->bk; + } + } + } + + mark_bin(av, victim_index); + victim->bk = bck; + victim->fd = fwd; + fwd->bk = victim; + bck->fd = victim; + } + + /* + If a large request, scan through the chunks of current bin in + sorted order to find smallest that fits. This is the only step + where an unbounded number of chunks might be scanned without doing + anything useful with them. However the lists tend to be very + short. + */ + + if (!in_smallbin_range(nb)) { + bin = bin_at(av, idx); + + /* skip scan if largest chunk is too small */ + if ((victim = last(bin)) != bin && + (long)(chunksize(first(bin))) - (long)(nb) >= 0) { + do { + size = chunksize(victim); + remainder_size = (long)size - (long)nb; + + if (remainder_size >= 0) { + unlink(victim, bck, fwd); + + /* Exhaust */ + if (remainder_size < (long)MINSIZE) { + set_inuse_bit_at_offset(victim, size); + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + /* Split */ + else { + remainder = chunk_at_offset(victim, nb); + unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder; + remainder->bk = remainder->fd = unsorted_chunks(av); + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + set_foot(remainder, remainder_size); + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + } + } while ( (victim = victim->bk) != bin); + } + } + + /* + Search for a chunk by scanning bins, starting with next largest + bin. This search is strictly by best-fit; i.e., the smallest + (with ties going to approximately the least recently used) chunk + that fits is selected. + + The bitmap avoids needing to check that most blocks are nonempty. + The particular case of skipping all bins during warm-up phases + when no chunks have been returned yet is faster than it might look. + */ + + ++idx; + bin = bin_at(av,idx); + block = idx2block(idx); + map = av->binmap[block]; + bit = idx2bit(idx); + + for (;;) { + /* + Skip rest of block if there are no more set bits in this block. + */ + + if (bit > map || bit == 0) { + for (;;) { + if (++block >= BINMAPSIZE) /* out of bins */ + break; + + else if ( (map = av->binmap[block]) != 0) { + bin = bin_at(av, (block << BINMAPSHIFT)); + bit = 1; + break; + } + } + /* Optimizers seem to like this double-break better than goto */ + if (block >= BINMAPSIZE) + break; + } + + /* Advance to bin with set bit. There must be one. */ + while ((bit & map) == 0) { + bin = next_bin(bin); + bit <<= 1; + } + + victim = last(bin); + + /* False alarm -- the bin is empty. Clear the bit. */ + if (victim == bin) { + av->binmap[block] = map &= ~bit; /* Write through */ + bin = next_bin(bin); + bit <<= 1; + } + + /* We know the first chunk in this bin is big enough to use. */ + else { + size = chunksize(victim); + remainder_size = (long)size - (long)nb; + + assert(remainder_size >= 0); + + /* unlink */ + bck = victim->bk; + bin->bk = bck; + bck->fd = bin; + + + /* Exhaust */ + if (remainder_size < (long)MINSIZE) { + set_inuse_bit_at_offset(victim, size); + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + + /* Split */ + else { + remainder = chunk_at_offset(victim, nb); + + unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder; + remainder->bk = remainder->fd = unsorted_chunks(av); + /* advertise as last remainder */ + if (in_smallbin_range(nb)) + av->last_remainder = remainder; + + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + set_foot(remainder, remainder_size); + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + } + } + + /* + If large enough, split off the chunk bordering the end of memory + ("top"). Note that this use of top is in accord with the best-fit search + rule. In effect, top is treated as larger (and thus less well + fitting) than any other available chunk since it can be extended + to be as large as necessary (up to system limitations). + + We require that "top" always exists (i.e., has size >= MINSIZE) + after initialization, so if it would otherwise be exhuasted by + current request, it is replenished. (Among the reasons for + ensuring it exists is that we may need MINSIZE space to put in + fenceposts in sysmalloc.) + */ + + victim = av->top; + size = chunksize(victim); + remainder_size = (long)size - (long)nb; + + if (remainder_size >= (long)MINSIZE) { + remainder = chunk_at_offset(victim, nb); + av->top = remainder; + set_head(victim, nb | PREV_INUSE); + set_head(remainder, remainder_size | PREV_INUSE); + + check_malloced_chunk(victim, nb); + return chunk2mem(victim); + } + + /* + If there is space available in fastbins, consolidate and retry, + to possibly avoid expanding memory. This can occur only if nb is + in smallbin range so we didn't consolidate upon entry. + */ + + else if (have_fastchunks(av)) { + assert(in_smallbin_range(nb)); + idx = smallbin_index(nb); /* restore original bin index */ + malloc_consolidate(av); + } + + /* + Otherwise, relay to handle system-dependent cases + */ + else + return sYSMALLOc(nb, av); + } +} + + + +/* + Free routine. See running comments for algorithm description. +*/ + +#if __STD_C +void fREe(Void_t* mem) +#else +void fREe(mem) Void_t* mem; +#endif +{ + mstate av = get_malloc_state(); + + mchunkptr p; /* chunk corresponding to mem */ + INTERNAL_SIZE_T size; /* its size */ + mfastbinptr* fb; /* associated fastbin */ + mchunkptr nextchunk; /* next contiguous chunk */ + INTERNAL_SIZE_T nextsize; /* its size */ + int nextinuse; /* true if nextchunk is used */ + INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */ + mchunkptr bck; /* misc temp for linking */ + mchunkptr fwd; /* misc temp for linking */ + + + /* free(0) has no effect */ + if (mem != 0) { + + p = mem2chunk(mem); + check_inuse_chunk(p); + + size = chunksize(p); + + /* + If eligible, place chunk on a fastbin so it can be found + and used quickly in malloc. + */ + + if ((unsigned long)size <= (unsigned long)av->max_fast + +#if TRIM_FASTBINS + /* + If TRIM_FASTBINS set, don't place chunks + bordering top into fastbins + */ + && (chunk_at_offset(p, size) != av->top) +#endif + ) { + + set_fastchunks(av); + fb = &(av->fastbins[fastbin_index(size)]); + p->fd = *fb; + *fb = p; + } + + /* + Consolidate non-mmapped chunks as they arrive. + */ + + else if (!chunk_is_mmapped(p)) { + + nextchunk = chunk_at_offset(p, size); + + /* consolidate backward */ + if (!prev_inuse(p)) { + prevsize = p->prev_size; + size += prevsize; + p = chunk_at_offset(p, -((long) prevsize)); + unlink(p, bck, fwd); + } + + nextsize = chunksize(nextchunk); + + if (nextchunk != av->top) { + + /* get and clear inuse bit */ + nextinuse = inuse_bit_at_offset(nextchunk, nextsize); + set_head(nextchunk, nextsize); + + /* consolidate forward */ + if (!nextinuse) { + unlink(nextchunk, bck, fwd); + size += nextsize; + } + + /* + Place chunk in unsorted chunk list. Chunks are + not placed into regular bins until after they have + been given one chance to be used in malloc. + */ + + bck = unsorted_chunks(av); + fwd = bck->fd; + p->bk = bck; + p->fd = fwd; + bck->fd = p; + fwd->bk = p; + + set_head(p, size | PREV_INUSE); + set_foot(p, size); + } + + /* + If the chunk borders the current high end of memory, + consolidate into top + */ + + else { + size += nextsize; + set_head(p, size | PREV_INUSE); + av->top = p; + + /* + If the total unused topmost memory exceeds trim + threshold, ask malloc_trim to reduce top. + + Unless max_fast is 0, we don't know if there are fastbins + bordering top, so we cannot tell for sure whether threshold has + been reached unless fastbins are consolidated. But we don't + want to consolidate on each free. As a compromise, + consolidation is performed if half the threshold is + reached. + + */ + + if ((unsigned long)(size) > (unsigned long)(av->trim_threshold / 2)) { + if (have_fastchunks(av)) { + malloc_consolidate(av); + size = chunksize(av->top); + } + + if ((unsigned long)(size) > (unsigned long)(av->trim_threshold)) + sYSTRIm(av->top_pad, av); + } + } + } + + /* + If the chunk was allocated via mmap, release via munmap() + Note that if HAVE_MMAP is false but chunk_is_mmapped is + true, then user must have overwritten memory. There's nothing + we can do to catch this error unless DEBUG is set, in which case + check_inuse_chunk (above) will have triggered error. + */ + + else { +#if HAVE_MMAP + int ret; + INTERNAL_SIZE_T offset = p->prev_size; + av->n_mmaps--; + av->mmapped_mem -= (size + offset); + ret = munmap((char*)p - offset, size + offset); + /* munmap returns non-zero on failure */ + assert(ret == 0); +#endif + } + } +} + + + +/* + malloc_consolidate is a specialized version of free() that tears + down chunks held in fastbins. Free itself cannot be used for this + purpose since, among other things, it might place chunks back onto + fastbins. So, instead, we need to use a minor variant of the same + code. + + Also, because this routine needs to be called the first time through + malloc anyway, it turns out to be the perfect place to bury + initialization code. +*/ + +#if __STD_C +static void malloc_consolidate(mstate av) +#else +static void malloc_consolidate(av) mstate av; +#endif +{ + mfastbinptr* fb; + mfastbinptr* maxfb; + mchunkptr p; + mchunkptr nextp; + mchunkptr unsorted_bin; + mchunkptr first_unsorted; + + /* These have same use as in free() */ + mchunkptr nextchunk; + INTERNAL_SIZE_T size; + INTERNAL_SIZE_T nextsize; + INTERNAL_SIZE_T prevsize; + int nextinuse; + mchunkptr bck; + mchunkptr fwd; + + /* + If max_fast is 0, we know that malloc hasn't + yet been initialized, in which case do so. + */ + + if (av->max_fast == 0) { + malloc_init_state(av); + check_malloc_state(); + } + else if (have_fastchunks(av)) { + clear_fastchunks(av); + + unsorted_bin = unsorted_chunks(av); + + /* + Remove each chunk from fast bin and consolidate it, placing it + then in unsorted bin. Among other reasons for doing this, + placing in unsorted bin avoids needing to calculate actual bins + until malloc is sure that chunks aren't immediately going to be + reused anyway. + */ + + maxfb = &(av->fastbins[fastbin_index(av->max_fast)]); + fb = &(av->fastbins[0]); + do { + if ( (p = *fb) != 0) { + *fb = 0; + + do { + check_inuse_chunk(p); + nextp = p->fd; + + /* Slightly streamlined version of consolidation code in free() */ + size = p->size & ~PREV_INUSE; + nextchunk = chunk_at_offset(p, size); + + if (!prev_inuse(p)) { + prevsize = p->prev_size; + size += prevsize; + p = chunk_at_offset(p, -((long) prevsize)); + unlink(p, bck, fwd); + } + + nextsize = chunksize(nextchunk); + + if (nextchunk != av->top) { + + nextinuse = inuse_bit_at_offset(nextchunk, nextsize); + set_head(nextchunk, nextsize); + + if (!nextinuse) { + size += nextsize; + unlink(nextchunk, bck, fwd); + } + + first_unsorted = unsorted_bin->fd; + unsorted_bin->fd = p; + first_unsorted->bk = p; + + set_head(p, size | PREV_INUSE); + p->bk = unsorted_bin; + p->fd = first_unsorted; + set_foot(p, size); + } + + else { + size += nextsize; + set_head(p, size | PREV_INUSE); + av->top = p; + } + + } while ( (p = nextp) != 0); + + } + } while (fb++ != maxfb); + } +} + + + + +/* + Realloc algorithm cases: + + * Chunks that were obtained via mmap cannot be extended or shrunk + unless HAVE_MREMAP is defined, in which case mremap is used. + Otherwise, if the reallocation is for additional space, they are + copied. If for less, they are just left alone. + + * Otherwise, if the reallocation is for additional space, and the + chunk can be extended, it is, else a malloc-copy-free sequence is + taken. There are several different ways that a chunk could be + extended. All are tried: + + * Extending forward into following adjacent free chunk. + * Shifting backwards, joining preceding adjacent space + * Both shifting backwards and extending forward. + * Extending into newly sbrked space + + * If there is not enough memory available to realloc, realloc + returns null, but does NOT free the existing space. + + * If the reallocation is for less space, the newly unused space is + lopped off and freed. Unless the #define REALLOC_ZERO_BYTES_FREES + is set, realloc with a size argument of zero (re)allocates a + minimum-sized chunk. + + + The old unix realloc convention of allowing the last-free'd chunk + to be used as an argument to realloc is no longer supported. + I don't know of any programs still relying on this feature, + and allowing it would also allow too many other incorrect + usages of realloc to be sensible. +*/ + +#if __STD_C +Void_t* rEALLOc(Void_t* oldmem, size_t bytes) +#else +Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes; +#endif +{ + mstate av = get_malloc_state(); + + INTERNAL_SIZE_T nb; /* padded request size */ + + mchunkptr oldp; /* chunk corresponding to oldmem */ + INTERNAL_SIZE_T oldsize; /* its size */ + + mchunkptr newp; /* chunk to return */ + INTERNAL_SIZE_T newsize; /* its size */ + Void_t* newmem; /* corresponding user mem */ + + mchunkptr next; /* next contiguous chunk after oldp */ + mchunkptr prev; /* previous contiguous chunk before oldp */ + + mchunkptr remainder; /* extra space at end of newp */ + long remainder_size; /* its size */ + + mchunkptr bck; /* misc temp for linking */ + mchunkptr fwd; /* misc temp for linking */ + + INTERNAL_SIZE_T copysize; /* bytes to copy */ + int ncopies; /* INTERNAL_SIZE_T words to copy */ + INTERNAL_SIZE_T* s; /* copy source */ + INTERNAL_SIZE_T* d; /* copy destination */ + + +#ifdef REALLOC_ZERO_BYTES_FREES + if (bytes == 0) { + fREe(oldmem); + return 0; + } +#endif + + /* realloc of null is supposed to be same as malloc */ + if (oldmem == 0) return mALLOc(bytes); + + checked_request2size(bytes, nb); + + oldp = mem2chunk(oldmem); + oldsize = chunksize(oldp); + + check_inuse_chunk(oldp); + + if (!chunk_is_mmapped(oldp)) { + + if ((unsigned long)(oldsize) >= (unsigned long)(nb)) { + /* already big enough; split below */ + newp = oldp; + newsize = oldsize; + } + + else { + newp = 0; + newsize = 0; + + next = chunk_at_offset(oldp, oldsize); + + if (next == av->top) { /* Expand forward into top */ + newsize = oldsize + chunksize(next); + + if ((unsigned long)(newsize) >= (unsigned long)(nb + MINSIZE)) { + set_head_size(oldp, nb); + av->top = chunk_at_offset(oldp, nb); + set_head(av->top, (newsize - nb) | PREV_INUSE); + return chunk2mem(oldp); + } + + else if (!prev_inuse(oldp)) { /* Shift backwards + top */ + prev = prev_chunk(oldp); + newsize += chunksize(prev); + + if ((unsigned long)(newsize) >= (unsigned long)(nb + MINSIZE)) { + newp = prev; + unlink(prev, bck, fwd); + av->top = chunk_at_offset(newp, nb); + set_head(av->top, (newsize - nb) | PREV_INUSE); + newsize = nb; + } + } + } + + else if (!inuse(next)) { /* Forward into next chunk */ + newsize = oldsize + chunksize(next); + + if (((unsigned long)(newsize) >= (unsigned long)(nb))) { + newp = oldp; + unlink(next, bck, fwd); + } + + else if (!prev_inuse(oldp)) { /* Forward + backward */ + prev = prev_chunk(oldp); + newsize += chunksize(prev); + + if (((unsigned long)(newsize) >= (unsigned long)(nb))) { + newp = prev; + unlink(prev, bck, fwd); + unlink(next, bck, fwd); + } + } + } + + else if (!prev_inuse(oldp)) { /* Backward only */ + prev = prev_chunk(oldp); + newsize = oldsize + chunksize(prev); + + if ((unsigned long)(newsize) >= (unsigned long)(nb)) { + newp = prev; + unlink(prev, bck, fwd); + } + } + + if (newp != 0) { + if (newp != oldp) { + /* Backward copies are not worth unrolling */ + MALLOC_COPY(chunk2mem(newp), oldmem, oldsize - SIZE_SZ, 1); + } + } + + /* Must allocate */ + else { + newmem = mALLOc(nb - MALLOC_ALIGN_MASK); + if (newmem == 0) + return 0; /* propagate failure */ + + newp = mem2chunk(newmem); + newsize = chunksize(newp); + + /* + Avoid copy if newp is next chunk after oldp. + */ + if (newp == next) { + newsize += oldsize; + newp = oldp; + } + else { + + /* + Unroll copy of <= 36 bytes (72 if 8byte sizes) + We know that contents have an odd number of + INTERNAL_SIZE_T-sized words; minimally 3. + */ + + copysize = oldsize - SIZE_SZ; + s = (INTERNAL_SIZE_T*)oldmem; + d = (INTERNAL_SIZE_T*)(chunk2mem(newp)); + ncopies = copysize / sizeof(INTERNAL_SIZE_T); + assert(ncopies >= 3); + + if (ncopies > 9) + MALLOC_COPY(d, s, copysize, 0); + + else { + *(d+0) = *(s+0); + *(d+1) = *(s+1); + *(d+2) = *(s+2); + if (ncopies > 4) { + *(d+3) = *(s+3); + *(d+4) = *(s+4); + if (ncopies > 6) { + *(d+5) = *(s+5); + *(d+6) = *(s+6); + if (ncopies > 8) { + *(d+7) = *(s+7); + *(d+8) = *(s+8); + } + } + } + } + + fREe(oldmem); + check_inuse_chunk(newp); + return chunk2mem(newp); + } + } + } + + + /* If possible, free extra space in old or extended chunk */ + + remainder_size = (long)newsize - (long)nb; + assert(remainder_size >= 0); + + if (remainder_size >= (long)MINSIZE) { /* split remainder */ + remainder = chunk_at_offset(newp, nb); + set_head_size(newp, nb); + set_head(remainder, remainder_size | PREV_INUSE); + /* Mark remainder as inuse so free() won't complain */ + set_inuse_bit_at_offset(remainder, remainder_size); + fREe(chunk2mem(remainder)); + } + + else { /* not enough extra to split off */ + set_head_size(newp, newsize); + set_inuse_bit_at_offset(newp, newsize); + } + + check_inuse_chunk(newp); + return chunk2mem(newp); + } + + /* + Handle mmap cases + */ + + else { +#if HAVE_MMAP + +#if HAVE_MREMAP + INTERNAL_SIZE_T offset = oldp->prev_size; + size_t pagemask = av->pagesize - 1; + char *cp; + unsigned long sum; + + /* Note the extra SIZE_SZ overhead */ + newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask; + + /* don't need to remap if still within same page */ + if (oldsize == newsize - offset) + return oldmem; + + cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1); + + if (cp != (char*)MORECORE_FAILURE) { + + newp = (mchunkptr)(cp + offset); + set_head(newp, (newsize - offset)|IS_MMAPPED); + + assert(aligned_OK(chunk2mem(newp))); + assert((newp->prev_size == offset)); + + /* update statistics */ + sum = av->mmapped_mem += newsize - oldsize; + if (sum > (unsigned long)(av->max_mmapped_mem)) + av->max_mmapped_mem = sum; + sum += av->sbrked_mem; + if (sum > (unsigned long)(av->max_total_mem)) + av->max_total_mem = sum; + + return chunk2mem(newp); + } + +#endif + + /* Note the extra SIZE_SZ overhead. */ + if ((long)oldsize - (long)SIZE_SZ >= (long)nb) + newmem = oldmem; /* do nothing */ + else { + /* Must alloc, copy, free. */ + newmem = mALLOc(nb - MALLOC_ALIGN_MASK); + if (newmem != 0) { + MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ, 0); + fREe(oldmem); + } + } + return newmem; + +#else + /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */ + check_malloc_state(); + MALLOC_FAILURE_ACTION; + return 0; +#endif + } + +} + + + +/* + memalign requests more than enough space from malloc, finds a spot + within that chunk that meets the alignment request, and then + possibly frees the leading and trailing space. + + Alignments must be powers of two. If the argument is not a + power of two, the nearest greater power is used. + + 8-byte alignment is guaranteed by normal malloc calls, so don't + bother calling memalign with an argument of 8 or less. + + Overreliance on memalign is a sure way to fragment space. +*/ + + +#if __STD_C +Void_t* mEMALIGn(size_t alignment, size_t bytes) +#else +Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes; +#endif +{ + INTERNAL_SIZE_T nb; /* padded request size */ + char* m; /* memory returned by malloc call */ + mchunkptr p; /* corresponding chunk */ + char* brk; /* alignment point within p */ + mchunkptr newp; /* chunk to return */ + INTERNAL_SIZE_T newsize; /* its size */ + INTERNAL_SIZE_T leadsize; /* leading space befor alignment point */ + mchunkptr remainder; /* spare room at end to split off */ + long remainder_size; /* its size */ + + + /* If need less alignment than we give anyway, just relay to malloc */ + + if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes); + + /* Otherwise, ensure that it is at least a minimum chunk size */ + + if (alignment < MINSIZE) alignment = MINSIZE; + + /* Make sure alignment is power of 2 (in case MINSIZE is not). */ + if ((alignment & (alignment - 1)) != 0) { + size_t a = MALLOC_ALIGNMENT * 2; + while ((unsigned long)a < (unsigned long)alignment) a <<= 1; + alignment = a; + } + + checked_request2size(bytes, nb); + + /* Call malloc with worst case padding to hit alignment. */ + + m = (char*)(mALLOc(nb + alignment + MINSIZE)); + + if (m == 0) return 0; /* propagate failure */ + + p = mem2chunk(m); + + if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */ + + /* + Find an aligned spot inside chunk. Since we need to give back + leading space in a chunk of at least MINSIZE, if the first + calculation places us at a spot with less than MINSIZE leader, + we can move to the next aligned spot -- we've allocated enough + total room so that this is always possible. + */ + + brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) & + -((signed long) alignment)); + if ((long)(brk - (char*)(p)) < (long)MINSIZE) + brk = brk + alignment; + + newp = (mchunkptr)brk; + leadsize = brk - (char*)(p); + newsize = chunksize(p) - leadsize; + + /* For mmapped chunks, just adjust offset */ + if (chunk_is_mmapped(p)) { + newp->prev_size = p->prev_size + leadsize; + set_head(newp, newsize|IS_MMAPPED); + return chunk2mem(newp); + } + + /* Otherwise, give back leader, use the rest */ + + set_head(newp, newsize | PREV_INUSE); + set_inuse_bit_at_offset(newp, newsize); + set_head_size(p, leadsize); + fREe(chunk2mem(p)); + p = newp; + + assert (newsize >= nb && + (((unsigned long)(chunk2mem(p))) % alignment) == 0); + } + + /* Also give back spare room at the end */ + if (!chunk_is_mmapped(p)) { + + remainder_size = (long)(chunksize(p)) - (long)nb; + + if (remainder_size >= (long)MINSIZE) { + remainder = chunk_at_offset(p, nb); + set_head(remainder, remainder_size | PREV_INUSE); + set_head_size(p, nb); + fREe(chunk2mem(remainder)); + } + } + + check_inuse_chunk(p); + return chunk2mem(p); + +} + + + + +/* + calloc calls malloc, then zeroes out the allocated chunk. +*/ + +#if __STD_C +Void_t* cALLOc(size_t n_elements, size_t elem_size) +#else +Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size; +#endif +{ + mchunkptr p; + INTERNAL_SIZE_T clearsize; + int nclears; + INTERNAL_SIZE_T* d; + + Void_t* mem = mALLOc(n_elements * elem_size); + + if (mem != 0) { + p = mem2chunk(mem); + if (!chunk_is_mmapped(p)) { /* don't need to clear mmapped space */ + + /* + Unroll clear of <= 36 bytes (72 if 8byte sizes) + We know that contents have an odd number of + INTERNAL_SIZE_T-sized words; minimally 3. + */ + + d = (INTERNAL_SIZE_T*)mem; + clearsize = chunksize(p) - SIZE_SZ; + nclears = clearsize / sizeof(INTERNAL_SIZE_T); + assert(nclears >= 3); + + if (nclears > 9) + MALLOC_ZERO(d, clearsize); + + else { + *(d+0) = 0; + *(d+1) = 0; + *(d+2) = 0; + if (nclears > 4) { + *(d+3) = 0; + *(d+4) = 0; + if (nclears > 6) { + *(d+5) = 0; + *(d+6) = 0; + if (nclears > 8) { + *(d+7) = 0; + *(d+8) = 0; + } + } + } + } + } + } + return mem; +} + + +/* + cfree just calls free. It is needed/defined on some systems + that pair it with calloc, presumably for odd historical reasons + (such as: cfree is used in example code in first edition of K&R). +*/ + +#if __STD_C +void cFREe(Void_t *mem) +#else +void cFREe(mem) Void_t *mem; +#endif +{ + fREe(mem); +} + + + + + +/* + valloc just invokes memalign with alignment argument equal + to the page size of the system (or as near to this as can + be figured out from all the includes/defines above.) +*/ + +#if __STD_C +Void_t* vALLOc(size_t bytes) +#else +Void_t* vALLOc(bytes) size_t bytes; +#endif +{ + /* Ensure initialization/consolidation */ + mstate av = get_malloc_state(); + malloc_consolidate(av); + return mEMALIGn(av->pagesize, bytes); +} + +/* + pvalloc just invokes valloc for the nearest pagesize + that will accommodate request +*/ + + +#if __STD_C +Void_t* pVALLOc(size_t bytes) +#else +Void_t* pVALLOc(bytes) size_t bytes; +#endif +{ + mstate av = get_malloc_state(); + size_t pagesz; + + /* Ensure initialization/consolidation */ + malloc_consolidate(av); + + pagesz = av->pagesize; + return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1)); +} + + +/* + Malloc_Trim gives memory back to the system (via negative + arguments to sbrk) if there is unused memory at the `high' end of + the malloc pool. You can call this after freeing large blocks of + memory to potentially reduce the system-level memory requirements + of a program. However, it cannot guarantee to reduce memory. Under + some allocation patterns, some large free blocks of memory will be + locked between two used chunks, so they cannot be given back to + the system. + + The `pad' argument to malloc_trim represents the amount of free + trailing space to leave untrimmed. If this argument is zero, + only the minimum amount of memory to maintain internal data + structures will be left (one page or less). Non-zero arguments + can be supplied to maintain enough trailing space to service + future expected allocations without having to re-obtain memory + from the system. + + Malloc_trim returns 1 if it actually released any memory, else 0. +*/ + +#if __STD_C +int mTRIm(size_t pad) +#else +int mTRIm(pad) size_t pad; +#endif +{ + mstate av = get_malloc_state(); + /* Ensure initialization/consolidation */ + malloc_consolidate(av); + + return sYSTRIm(pad, av); +} + +/* + malloc_usable_size tells you how many bytes you can actually use in + an allocated chunk, which may be more than you requested (although + often not). You can use this many bytes without worrying about + overwriting other allocated objects. Not a particularly great + programming practice, but still sometimes useful. +*/ + +#if __STD_C +size_t mUSABLe(Void_t* mem) +#else +size_t mUSABLe(mem) Void_t* mem; +#endif +{ + mchunkptr p; + if (mem != 0) { + p = mem2chunk(mem); + if (chunk_is_mmapped(p)) + return chunksize(p) - 2*SIZE_SZ; + else if (inuse(p)) + return chunksize(p) - SIZE_SZ; + } + return 0; +} + + + + +/* + mallinfo returns a copy of updated current mallinfo. +*/ + +struct mallinfo mALLINFo() +{ + mstate av = get_malloc_state(); + struct mallinfo mi; + int i; + mbinptr b; + mchunkptr p; + INTERNAL_SIZE_T avail; + int navail; + int nfastblocks; + int fastbytes; + + /* Ensure initialization */ + if (av->top == 0) malloc_consolidate(av); + + check_malloc_state(); + + /* Account for top */ + avail = chunksize(av->top); + navail = 1; /* top always exists */ + + /* traverse fastbins */ + nfastblocks = 0; + fastbytes = 0; + + for (i = 0; i < NFASTBINS; ++i) { + for (p = av->fastbins[i]; p != 0; p = p->fd) { + ++nfastblocks; + fastbytes += chunksize(p); + } + } + + avail += fastbytes; + + /* traverse regular bins */ + for (i = 1; i < NBINS; ++i) { + b = bin_at(av, i); + for (p = last(b); p != b; p = p->bk) { + avail += chunksize(p); + navail++; + } + } + + mi.smblks = nfastblocks; + mi.ordblks = navail; + mi.fordblks = avail; + mi.uordblks = av->sbrked_mem - avail; + mi.arena = av->sbrked_mem; + mi.hblks = av->n_mmaps; + mi.hblkhd = av->mmapped_mem; + mi.fsmblks = fastbytes; + mi.keepcost = chunksize(av->top); + mi.usmblks = av->max_total_mem; + return mi; +} + + + +/* + malloc_stats prints on stderr the amount of space obtained from the + system (both via sbrk and mmap), the maximum amount (which may be + more than current if malloc_trim and/or munmap got called), and the + current number of bytes allocated via malloc (or realloc, etc) but + not yet freed. Note that this is the number of bytes allocated, not + the number requested. It will be larger than the number requested + because of alignment and bookkeeping overhead. Because it includes + alignment wastage as being in use, this figure may be greater than zero + even when no user-level chunks are allocated. + + The reported current and maximum system memory can be inaccurate if + a program makes other calls to system memory allocation functions + (normally sbrk) outside of malloc. + + malloc_stats prints only the most commonly interesting statistics. + More information can be obtained by calling mallinfo. +*/ + +void mSTATs() +{ + struct mallinfo mi = mALLINFo(); + +#ifdef WIN32 + { + unsigned long free, reserved, committed; + vminfo (&free, &reserved, &committed); + fprintf(stderr, "free bytes = %10lu\n", + free); + fprintf(stderr, "reserved bytes = %10lu\n", + reserved); + fprintf(stderr, "committed bytes = %10lu\n", + committed); + } +#endif + + + fprintf(stderr, "max system bytes = %10lu\n", + (unsigned long)(mi.usmblks)); + fprintf(stderr, "system bytes = %10lu\n", + (unsigned long)(mi.arena + mi.hblkhd)); + fprintf(stderr, "in use bytes = %10lu\n", + (unsigned long)(mi.uordblks + mi.hblkhd)); + +#ifdef WIN32 + { + unsigned long kernel, user; + if (cpuinfo (TRUE, &kernel, &user)) { + fprintf(stderr, "kernel ms = %10lu\n", + kernel); + fprintf(stderr, "user ms = %10lu\n", + user); + } + } +#endif +} + + + +/* + mallopt is the general SVID/XPG interface to tunable parameters. + The format is to provide a (parameter-number, parameter-value) + pair. mallopt then sets the corresponding parameter to the + argument value if it can (i.e., so long as the value is + meaningful), and returns 1 if successful else 0. See descriptions + of tunable parameters above for meanings. +*/ + +#if __STD_C +int mALLOPt(int param_number, int value) +#else +int mALLOPt(param_number, value) int param_number; int value; +#endif +{ + mstate av = get_malloc_state(); + /* Ensure initialization/consolidation */ + malloc_consolidate(av); + + switch(param_number) { + case M_MXFAST: + if (value >= 0 && value <= MAX_FAST_SIZE) { + av->max_fast = req2max_fast(value); + return 1; + } + else + return 0; + + case M_TRIM_THRESHOLD: + av->trim_threshold = value; + return 1; + + case M_TOP_PAD: + av->top_pad = value; + return 1; + + case M_MMAP_THRESHOLD: + av->mmap_threshold = value; + return 1; + + case M_MMAP_MAX: +#if HAVE_MMAP + av->n_mmaps_max = value; + return 1; +#else + if (value != 0) + return 0; + else { + av->n_mmaps_max = value; + return 1; + } +#endif + + default: + return 0; + } +} + + +/* -------------------------------------------------------------- */ + +/* + Emulation of sbrk for win32. + Donated by J. Walter <Walter@GeNeSys-e.de>. + For additional information about this code, and malloc on Win32, see + http://www.genesys-e.de/jwalter/ + +*/ + + +#ifdef WIN32 + +#ifdef _DEBUG +/* #define TRACE */ +#endif + +/* Support for USE_MALLOC_LOCK */ +#ifdef USE_MALLOC_LOCK + +/* Wait for spin lock */ +static int slwait (int *sl) { + while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0) + Sleep (0); + return 0; +} + +/* Release spin lock */ +static int slrelease (int *sl) { + InterlockedExchange (sl, 0); + return 0; +} + +#ifdef NEEDED +/* Spin lock for emulation code */ +static int g_sl; +#endif + +#endif /* USE_MALLOC_LOCK */ + +/* getpagesize for windows */ +static long getpagesize (void) { + static long g_pagesize = 0; + if (! g_pagesize) { + SYSTEM_INFO system_info; + GetSystemInfo (&system_info); + g_pagesize = system_info.dwPageSize; + } + return g_pagesize; +} +static long getregionsize (void) { + static long g_regionsize = 0; + if (! g_regionsize) { + SYSTEM_INFO system_info; + GetSystemInfo (&system_info); + g_regionsize = system_info.dwAllocationGranularity; + } + return g_regionsize; +} + +/* A region list entry */ +typedef struct _region_list_entry { + void *top_allocated; + void *top_committed; + void *top_reserved; + long reserve_size; + struct _region_list_entry *previous; +} region_list_entry; + +/* Allocate and link a region entry in the region list */ +static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) { + region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry)); + if (! next) + return FALSE; + next->top_allocated = (char *) base_reserved; + next->top_committed = (char *) base_reserved; + next->top_reserved = (char *) base_reserved + reserve_size; + next->reserve_size = reserve_size; + next->previous = *last; + *last = next; + return TRUE; +} +/* Free and unlink the last region entry from the region list */ +static int region_list_remove (region_list_entry **last) { + region_list_entry *previous = (*last)->previous; + if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last)) + return FALSE; + *last = previous; + return TRUE; +} + +#define CEIL(size,to) (((size)+(to)-1)&~((to)-1)) +#define FLOOR(size,to) ((size)&~((to)-1)) + +#define SBRK_SCALE 0 +/* #define SBRK_SCALE 1 */ +/* #define SBRK_SCALE 2 */ +/* #define SBRK_SCALE 4 */ + +/* sbrk for windows */ +static void *sbrk (long size) { + static long g_pagesize, g_my_pagesize; + static long g_regionsize, g_my_regionsize; + static region_list_entry *g_last; + void *result = (void *) MORECORE_FAILURE; +#ifdef TRACE + printf ("sbrk %d\n", size); +#endif +#if defined (USE_MALLOC_LOCK) && defined (NEEDED) + /* Wait for spin lock */ + slwait (&g_sl); +#endif + /* First time initialization */ + if (! g_pagesize) { + g_pagesize = getpagesize (); + g_my_pagesize = g_pagesize << SBRK_SCALE; + } + if (! g_regionsize) { + g_regionsize = getregionsize (); + g_my_regionsize = g_regionsize << SBRK_SCALE; + } + if (! g_last) { + if (! region_list_append (&g_last, 0, 0)) + goto sbrk_exit; + } + /* Assert invariants */ + assert (g_last); + assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated && + g_last->top_allocated <= g_last->top_committed); + assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed && + g_last->top_committed <= g_last->top_reserved && + (unsigned) g_last->top_committed % g_pagesize == 0); + assert ((unsigned) g_last->top_reserved % g_regionsize == 0); + assert ((unsigned) g_last->reserve_size % g_regionsize == 0); + /* Allocation requested? */ + if (size >= 0) { + /* Allocation size is the requested size */ + long allocate_size = size; + /* Compute the size to commit */ + long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed; + /* Do we reach the commit limit? */ + if (to_commit > 0) { + /* Round size to commit */ + long commit_size = CEIL (to_commit, g_my_pagesize); + /* Compute the size to reserve */ + long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved; + /* Do we reach the reserve limit? */ + if (to_reserve > 0) { + /* Compute the remaining size to commit in the current region */ + long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed; + if (remaining_commit_size > 0) { + /* Assert preconditions */ + assert ((unsigned) g_last->top_committed % g_pagesize == 0); + assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); { + /* Commit this */ + void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size, + MEM_COMMIT, PAGE_READWRITE); + /* Check returned pointer for consistency */ + if (base_committed != g_last->top_committed) + goto sbrk_exit; + /* Assert postconditions */ + assert ((unsigned) base_committed % g_pagesize == 0); +#ifdef TRACE + printf ("Commit %p %d\n", base_committed, remaining_commit_size); +#endif + /* Adjust the regions commit top */ + g_last->top_committed = (char *) base_committed + remaining_commit_size; + } + } { + /* Now we are going to search and reserve. */ + int contiguous = -1; + int found = FALSE; + MEMORY_BASIC_INFORMATION memory_info; + void *base_reserved; + long reserve_size; + do { + /* Assume contiguous memory */ + contiguous = TRUE; + /* Round size to reserve */ + reserve_size = CEIL (to_reserve, g_my_regionsize); + /* Start with the current region's top */ + memory_info.BaseAddress = g_last->top_reserved; + /* Assert preconditions */ + assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0); + assert (0 < reserve_size && reserve_size % g_regionsize == 0); + while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) { + /* Assert postconditions */ + assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0); +#ifdef TRACE + printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize, + memory_info.State == MEM_FREE ? "FREE": + (memory_info.State == MEM_RESERVE ? "RESERVED": + (memory_info.State == MEM_COMMIT ? "COMMITTED": "?"))); +#endif + /* Region is free, well aligned and big enough: we are done */ + if (memory_info.State == MEM_FREE && + (unsigned) memory_info.BaseAddress % g_regionsize == 0 && + memory_info.RegionSize >= (unsigned) reserve_size) { + found = TRUE; + break; + } + /* From now on we can't get contiguous memory! */ + contiguous = FALSE; + /* Recompute size to reserve */ + reserve_size = CEIL (allocate_size, g_my_regionsize); + memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize; + /* Assert preconditions */ + assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0); + assert (0 < reserve_size && reserve_size % g_regionsize == 0); + } + /* Search failed? */ + if (! found) + goto sbrk_exit; + /* Assert preconditions */ + assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0); + assert (0 < reserve_size && reserve_size % g_regionsize == 0); + /* Try to reserve this */ + base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size, + MEM_RESERVE, PAGE_NOACCESS); + if (! base_reserved) { + int rc = GetLastError (); + if (rc != ERROR_INVALID_ADDRESS) + goto sbrk_exit; + } + /* A null pointer signals (hopefully) a race condition with another thread. */ + /* In this case, we try again. */ + } while (! base_reserved); + /* Check returned pointer for consistency */ + if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress) + goto sbrk_exit; + /* Assert postconditions */ + assert ((unsigned) base_reserved % g_regionsize == 0); +#ifdef TRACE + printf ("Reserve %p %d\n", base_reserved, reserve_size); +#endif + /* Did we get contiguous memory? */ + if (contiguous) { + long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated; + /* Adjust allocation size */ + allocate_size -= start_size; + /* Adjust the regions allocation top */ + g_last->top_allocated = g_last->top_committed; + /* Recompute the size to commit */ + to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed; + /* Round size to commit */ + commit_size = CEIL (to_commit, g_my_pagesize); + } + /* Append the new region to the list */ + if (! region_list_append (&g_last, base_reserved, reserve_size)) + goto sbrk_exit; + /* Didn't we get contiguous memory? */ + if (! contiguous) { + /* Recompute the size to commit */ + to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed; + /* Round size to commit */ + commit_size = CEIL (to_commit, g_my_pagesize); + } + } + } + /* Assert preconditions */ + assert ((unsigned) g_last->top_committed % g_pagesize == 0); + assert (0 < commit_size && commit_size % g_pagesize == 0); { + /* Commit this */ + void *base_committed = VirtualAlloc (g_last->top_committed, commit_size, + MEM_COMMIT, PAGE_READWRITE); + /* Check returned pointer for consistency */ + if (base_committed != g_last->top_committed) + goto sbrk_exit; + /* Assert postconditions */ + assert ((unsigned) base_committed % g_pagesize == 0); +#ifdef TRACE + printf ("Commit %p %d\n", base_committed, commit_size); +#endif + /* Adjust the regions commit top */ + g_last->top_committed = (char *) base_committed + commit_size; + } + } + /* Adjust the regions allocation top */ + g_last->top_allocated = (char *) g_last->top_allocated + allocate_size; + result = (char *) g_last->top_allocated - size; + /* Deallocation requested? */ + } else if (size < 0) { + long deallocate_size = - size; + /* As long as we have a region to release */ + while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) { + /* Get the size to release */ + long release_size = g_last->reserve_size; + /* Get the base address */ + void *base_reserved = (char *) g_last->top_reserved - release_size; + /* Assert preconditions */ + assert ((unsigned) base_reserved % g_regionsize == 0); + assert (0 < release_size && release_size % g_regionsize == 0); { + /* Release this */ + int rc = VirtualFree (base_reserved, 0, + MEM_RELEASE); + /* Check returned code for consistency */ + if (! rc) + goto sbrk_exit; +#ifdef TRACE + printf ("Release %p %d\n", base_reserved, release_size); +#endif + } + /* Adjust deallocation size */ + deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved; + /* Remove the old region from the list */ + if (! region_list_remove (&g_last)) + goto sbrk_exit; + } { + /* Compute the size to decommit */ + long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size); + if (to_decommit >= g_my_pagesize) { + /* Compute the size to decommit */ + long decommit_size = FLOOR (to_decommit, g_my_pagesize); + /* Compute the base address */ + void *base_committed = (char *) g_last->top_committed - decommit_size; + /* Assert preconditions */ + assert ((unsigned) base_committed % g_pagesize == 0); + assert (0 < decommit_size && decommit_size % g_pagesize == 0); { + /* Decommit this */ + int rc = VirtualFree ((char *) base_committed, decommit_size, + MEM_DECOMMIT); + /* Check returned code for consistency */ + if (! rc) + goto sbrk_exit; +#ifdef TRACE + printf ("Decommit %p %d\n", base_committed, decommit_size); +#endif + } + /* Adjust deallocation size and regions commit and allocate top */ + deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed; + g_last->top_committed = base_committed; + g_last->top_allocated = base_committed; + } + } + /* Adjust regions allocate top */ + g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size; + /* Check for underflow */ + if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated || + g_last->top_allocated > g_last->top_committed) { + /* Adjust regions allocate top */ + g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size; + goto sbrk_exit; + } + result = g_last->top_allocated; + } + /* Assert invariants */ + assert (g_last); + assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated && + g_last->top_allocated <= g_last->top_committed); + assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed && + g_last->top_committed <= g_last->top_reserved && + (unsigned) g_last->top_committed % g_pagesize == 0); + assert ((unsigned) g_last->top_reserved % g_regionsize == 0); + assert ((unsigned) g_last->reserve_size % g_regionsize == 0); + +sbrk_exit: +#if defined (USE_MALLOC_LOCK) && defined (NEEDED) + /* Release spin lock */ + slrelease (&g_sl); +#endif + return result; +} + +/* mmap for windows */ +static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) { + static long g_pagesize; + static long g_regionsize; +#ifdef TRACE + printf ("mmap %d\n", size); +#endif +#if defined (USE_MALLOC_LOCK) && defined (NEEDED) + /* Wait for spin lock */ + slwait (&g_sl); +#endif + /* First time initialization */ + if (! g_pagesize) + g_pagesize = getpagesize (); + if (! g_regionsize) + g_regionsize = getregionsize (); + /* Assert preconditions */ + assert ((unsigned) ptr % g_regionsize == 0); + assert (size % g_pagesize == 0); + /* Allocate this */ + ptr = VirtualAlloc (ptr, size, + MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE); + if (! ptr) { + ptr = (void *) MORECORE_FAILURE; + goto mmap_exit; + } + /* Assert postconditions */ + assert ((unsigned) ptr % g_regionsize == 0); +#ifdef TRACE + printf ("Commit %p %d\n", ptr, size); +#endif +mmap_exit: +#if defined (USE_MALLOC_LOCK) && defined (NEEDED) + /* Release spin lock */ + slrelease (&g_sl); +#endif + return ptr; +} + +/* munmap for windows */ +static long munmap (void *ptr, long size) { + static long g_pagesize; + static long g_regionsize; + int rc = MUNMAP_FAILURE; +#ifdef TRACE + printf ("munmap %p %d\n", ptr, size); +#endif +#if defined (USE_MALLOC_LOCK) && defined (NEEDED) + /* Wait for spin lock */ + slwait (&g_sl); +#endif + /* First time initialization */ + if (! g_pagesize) + g_pagesize = getpagesize (); + if (! g_regionsize) + g_regionsize = getregionsize (); + /* Assert preconditions */ + assert ((unsigned) ptr % g_regionsize == 0); + assert (size % g_pagesize == 0); + /* Free this */ + if (! VirtualFree (ptr, 0, + MEM_RELEASE)) + goto munmap_exit; + rc = 0; +#ifdef TRACE + printf ("Release %p %d\n", ptr, size); +#endif +munmap_exit: +#if defined (USE_MALLOC_LOCK) && defined (NEEDED) + /* Release spin lock */ + slrelease (&g_sl); +#endif + return rc; +} + +static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) { + MEMORY_BASIC_INFORMATION memory_info; + memory_info.BaseAddress = 0; + *free = *reserved = *committed = 0; + while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) { + switch (memory_info.State) { + case MEM_FREE: + *free += memory_info.RegionSize; + break; + case MEM_RESERVE: + *reserved += memory_info.RegionSize; + break; + case MEM_COMMIT: + *committed += memory_info.RegionSize; + break; + } + memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize; + } +} + +static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) { + if (whole) { + __int64 creation64, exit64, kernel64, user64; + int rc = GetProcessTimes (GetCurrentProcess (), + (FILETIME *) &creation64, + (FILETIME *) &exit64, + (FILETIME *) &kernel64, + (FILETIME *) &user64); + if (! rc) { + *kernel = 0; + *user = 0; + return FALSE; + } + *kernel = (unsigned long) (kernel64 / 10000); + *user = (unsigned long) (user64 / 10000); + return TRUE; + } else { + __int64 creation64, exit64, kernel64, user64; + int rc = GetThreadTimes (GetCurrentThread (), + (FILETIME *) &creation64, + (FILETIME *) &exit64, + (FILETIME *) &kernel64, + (FILETIME *) &user64); + if (! rc) { + *kernel = 0; + *user = 0; + return FALSE; + } + *kernel = (unsigned long) (kernel64 / 10000); + *user = (unsigned long) (user64 / 10000); + return TRUE; + } +} + +#endif /* WIN32 */ + +/* + +History: + + V2.7.0 + * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>. + * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for + helping test this.) + * memalign: check alignment arg + * realloc: use memmove when regions may overlap. + * Collect all cases in malloc requiring system memory into sYSMALLOc + * Use mmap as backup to sbrk, if available; fold these mmap-related + operations into others. + * Place all internal state in malloc_state + * Introduce fastbins (although similar to 2.5.1) + * Many minor tunings and cosmetic improvements + * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK + * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS + Thanks to Tony E. Bennett <tbennett@nvidia.com> and others. + * Adjust request2size to fit with MALLOC_FAILURE_ACTION. + * Include errno.h to support default failure action. + * Further improve WIN32 'sbrk()' emulation's 'findRegion()' routine + to avoid infinite loop when allocating initial memory larger + than RESERVED_SIZE and/or subsequent memory larger than + NEXT_SIZE. Thanks to Andreas Mueller <a.mueller at paradatec.de> + for finding this one. + + V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee) + * return null for negative arguments + * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com> + * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h' + (e.g. WIN32 platforms) + * Cleanup header file inclusion for WIN32 platforms + * Cleanup code to avoid Microsoft Visual C++ compiler complaints + * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing + memory allocation routines + * Set 'malloc_getpagesize' for WIN32 platforms (needs more work) + * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to + usage of 'assert' in non-WIN32 code + * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to + avoid infinite loop + * Always call 'fREe()' rather than 'free()' + + V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee) + * Fixed ordering problem with boundary-stamping + + V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee) + * Added pvalloc, as recommended by H.J. Liu + * Added 64bit pointer support mainly from Wolfram Gloger + * Added anonymously donated WIN32 sbrk emulation + * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen + * malloc_extend_top: fix mask error that caused wastage after + foreign sbrks + * Add linux mremap support code from HJ Liu + + V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee) + * Integrated most documentation with the code. + * Add support for mmap, with help from + Wolfram Gloger (Gloger@lrz.uni-muenchen.de). + * Use last_remainder in more cases. + * Pack bins using idea from colin@nyx10.cs.du.edu + * Use ordered bins instead of best-fit threshhold + * Eliminate block-local decls to simplify tracing and debugging. + * Support another case of realloc via move into top + * Fix error occuring when initial sbrk_base not word-aligned. + * Rely on page size for units instead of SBRK_UNIT to + avoid surprises about sbrk alignment conventions. + * Add mallinfo, mallopt. Thanks to Raymond Nijssen + (raymond@es.ele.tue.nl) for the suggestion. + * Add `pad' argument to malloc_trim and top_pad mallopt parameter. + * More precautions for cases where other routines call sbrk, + courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de). + * Added macros etc., allowing use in linux libc from + H.J. Lu (hjl@gnu.ai.mit.edu) + * Inverted this history list + + V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee) + * Re-tuned and fixed to behave more nicely with V2.6.0 changes. + * Removed all preallocation code since under current scheme + the work required to undo bad preallocations exceeds + the work saved in good cases for most test programs. + * No longer use return list or unconsolidated bins since + no scheme using them consistently outperforms those that don't + given above changes. + * Use best fit for very large chunks to prevent some worst-cases. + * Added some support for debugging + + V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee) + * Removed footers when chunks are in use. Thanks to + Paul Wilson (wilson@cs.texas.edu) for the suggestion. + + V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee) + * Added malloc_trim, with help from Wolfram Gloger + (wmglo@Dent.MED.Uni-Muenchen.DE). + + V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g) + + V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g) + * realloc: try to expand in both directions + * malloc: swap order of clean-bin strategy; + * realloc: only conditionally expand backwards + * Try not to scavenge used bins + * Use bin counts as a guide to preallocation + * Occasionally bin return list chunks in first scan + * Add a few optimizations from colin@nyx10.cs.du.edu + + V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g) + * faster bin computation & slightly different binning + * merged all consolidations to one part of malloc proper + (eliminating old malloc_find_space & malloc_clean_bin) + * Scan 2 returns chunks (not just 1) + * Propagate failure in realloc if malloc returns 0 + * Add stuff to allow compilation on non-ANSI compilers + from kpv@research.att.com + + V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu) + * removed potential for odd address access in prev_chunk + * removed dependency on getpagesize.h + * misc cosmetics and a bit more internal documentation + * anticosmetics: mangled names in macros to evade debugger strangeness + * tested on sparc, hp-700, dec-mips, rs6000 + with gcc & native cc (hp, dec only) allowing + Detlefs & Zorn comparison study (in SIGPLAN Notices.) + + Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu) + * Based loosely on libg++-1.2X malloc. (It retains some of the overall + structure of old version, but most details differ.) + +*/ + + diff --git a/src/libs/xpcom18a4/xpcom/build/nsOS2VACLegacy.cpp b/src/libs/xpcom18a4/xpcom/build/nsOS2VACLegacy.cpp new file mode 100644 index 00000000..c9c04b30 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/nsOS2VACLegacy.cpp @@ -0,0 +1,753 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the Mozilla.org code. + * + * The Initial Developer of the Original Code is + * innotek GmbH. + * Portions created by the Initial Developer are Copyright (C) 2003 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * innotek GmbH / Knut St. Osmundsen + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/* + * This module contains wrappers for a handful of XPCOM methods which someone + * have been so kind as to link their plugins against. This module will only + * provide the minimum of what necessary to make legacy plugins work with + * the GCC based mozilla. Luckily this only means the IBM oji JAVA plugins. + * + * Actually, I haven't seen npoji6 calling any of these yet. + */ + +/******************************************************************************* +* Defined Constants And Macros * +*******************************************************************************/ +/** @group Visual Age for C++ v3.6.5 target (OS/2). */ +/* @{ */ +/** Indicate Visual Age for C++ v3.6.5 target */ +#define VFT_VAC365 1 +/** VFTable/Interface Calling Convention for Win32. */ +#define VFTCALL _Optlink +/** First Entry which VAC uses. */ +#define VFTFIRST_DECL unsigned uFirst[2] +#define VFTFIRST_VAL() {0, 0}, +/** This deltas which VAC uses. */ +#define VFTDELTA_DECL(n) unsigned uDelta##n +#define VFTDELTA_VAL() 0, +/** @} */ + + +/******************************************************************************* +* Header Files * +*******************************************************************************/ +#include "nscore.h" +#include "nsIServiceManagerUtils.h" + + +/******************************************************************************* +* Structures and Typedefs * +*******************************************************************************/ +#ifndef __cplusplus +typedef struct nsID +{ + PRUint32 m0; + PRUint16 m1; + PRUint16 m2; + PRUint8 m3[8]; +} nsID, nsCID, nsIID; +#define REFNSIID const nsIID * + +typedef PRUint32 nsrefcnt; +#endif + + +/** + * nsISupports vftable. + */ +typedef struct vftable_nsISupports +{ + VFTFIRST_DECL; + nsresult (*VFTCALL QueryInterface)(void *pvThis, REFNSIID aIID, void** aInstancePtr); + VFTDELTA_DECL(QueryInterface); + nsrefcnt (*VFTCALL AddRef)(void *pvThis); + VFTDELTA_DECL(AddRef); + nsrefcnt (*VFTCALL Release)(void *pvThis); + VFTDELTA_DECL(Release); +} VFTnsISupports; + +/** + * nsGetServiceByCID::nsCOMPtr_helper vftable. + */ +typedef struct vftable_nsGetServiceByCID_nsCOMPtr_helper +{ + VFTFIRST_DECL; + /* virtual nsresult operator()( const nsIID&, void** ) const; */ + nsresult (*VFTCALL __operator_paratheses)(void *pvThis, REFNSIID aIID, void** aInstancePtr); + VFTDELTA_DECL(__operator_paratheses); + void * (*VFTCALL __destructor)(void *pvThis, unsigned __dtorFlags, unsigned __vtt); + VFTDELTA_DECL(__destructor); +} VFTnsGetServiceByCID_nsCOMPtr_helper; + +/** + * nsQueryInterface::nsCOMPtr_helper vftable. + */ +typedef struct vftable_nsQueryInterface_nsCOMPtr_helper +{ + VFTFIRST_DECL; + nsresult (*VFTCALL __operator_paratheses)(void *pvThis, REFNSIID aIID, void** aInstancePtr); + VFTDELTA_DECL(__operator_paratheses); +} VFTnsQueryInterface_nsCOMPtr_helper; + + + + +/** + * nsISupport object. + */ +typedef struct obj_nsISupports +{ + VFTnsISupports *pVFT; +} obj_nsISupports; + +/** + * nsCOMPtr_base object. + */ +typedef struct obj_nsCOMPtr_base +{ + obj_nsISupports *mRawPtr; +} obj_nsCOMPtr_base; + +/** + * nsGetServiceByCID_nsCOMPtr_helper object. + */ +typedef struct obj_nsGetServiceByCID_nsCOMPtr_helper +{ + VFTnsGetServiceByCID_nsCOMPtr_helper *pVFT; /* ?? */ + nsID *mCID; /* const nsCID& */ + void *mServiceManager;/* nsCOMPtr<nsIServiceManager> */ + nsresult *mErrorPtr; +} obj_nsGetServiceByCID_nsCOMPtr_helper; + +/** + * nsQueryInterface_nsCOMPtr_helper object. + */ +typedef struct obj_nsQueryInterface_nsCOMPtr_helper +{ + VFTnsQueryInterface_nsCOMPtr_helper *pVFT; /* ?? */ + obj_nsISupports *mRawPtr; /* const nsCID& */ + nsresult *mErrorPtr; +} obj_nsQueryInterface_nsCOMPtr_helper; + + + + +/** + * nsCOMPtr_base::~nsCOMPtr_base() + * + * @remark This guys doing the oji plugin have been very unfortunate to link in this + * without any similar new operator. The object is thus created in the plugin + * but freed by xpcom.dll. As the plugin and mozilla have different CRTs this + * is a good way of asking for trouble. But, they guys've been lucky, the VAC + * CRT might just handle this ok. + * However, we cannot perform this delete as we have no VAC CRT around, and + * hence we will leak this object. + * ---- + * assembly: + public __dt__13nsCOMPtr_baseFv +__dt__13nsCOMPtr_baseFv proc + push ebp + mov ebp,esp + sub esp,08h + mov [ebp+08h],eax; this + mov [ebp+0ch],edx; __dtorFlags + +; 63 if ( mRawPtr ) + mov eax,[ebp+08h]; this + cmp dword ptr [eax],0h + je @BLBL4 + +; 64 NSCAP_RELEASE(this, mRawPtr); + mov ecx,[ebp+08h]; this + mov ecx,[ecx] + mov ecx,[ecx] + mov eax,[ebp+08h]; this + mov eax,[eax] + add eax,[ecx+01ch] + mov ecx,[ebp+08h]; this + mov ecx,[ecx] + mov ecx,[ecx] + call dword ptr [ecx+018h] +@BLBL4: + +; 65 } + test byte ptr [ebp+0ch],01h; __dtorFlags + je @BLBL6 + mov eax,[ebp+08h]; this + call __dl__FPv +@BLBL6: + mov eax,[ebp+08h]; this + add esp,08h + pop ebp + ret +__dt__13nsCOMPtr_baseFv endp +*/ +extern "C" void * VFTCALL __dt__13nsCOMPtr_baseFv(void *pvThis, unsigned __dtorFlags) +{ + obj_nsCOMPtr_base *pThis = (obj_nsCOMPtr_base*)pvThis; +//asm("int $3"); + if (pThis->mRawPtr) + { + /* NSCAP_RELEASE(this, mRawPtr); */ + pThis->mRawPtr->pVFT->Release((char*)pThis->mRawPtr + pThis->mRawPtr->pVFT->uDeltaRelease); + } + + /* + * Delete the object... + * (As memtioned before we'll rather leak this.) + */ + #if 0 + if (!(__dtorFlags & 1)) + __dl__FPv(this) + #endif + + return pvThis; +} + +/** workaround for _Optlink bug.. */ +extern "C" void * VFTCALL _dt__13nsCOMPtr_baseFv(void *pvThis, unsigned __dtorFlags) +{ + return __dt__13nsCOMPtr_baseFv(pvThis, __dtorFlags); +} + + + +/** + * + * ----- + * assembly: +; 92 nsGetServiceByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const + align 010h + + public __cl__17nsGetServiceByCIDCFRC4nsIDPPv +__cl__17nsGetServiceByCIDCFRC4nsIDPPv proc + push ebp + mov ebp,esp + sub esp,014h + push ebx + sub esp,08h + mov [ebp+08h],eax; this + mov [ebp+0ch],edx; aIID + mov [ebp+010h],ecx; aInstancePtr + +; 94 nsresult status = NS_ERROR_FAILURE; + mov dword ptr [ebp-04h],080004005h; status + +; 95 if ( mServiceManager ) { + mov eax,[ebp+08h]; this + add eax,08h + call __opP13nsDerivedSafeXT17nsIServiceManager___8nsCOMPtrXT17nsIServiceManager_CFv + test eax,eax + je @BLBL13 + +; 96 status = mServiceManager->GetService(mCID, aIID, (void**)aInstancePtr); + mov eax,[ebp+08h]; this + add eax,08h + call __rf__8nsCOMPtrXT17nsIServiceManager_CFv + mov [ebp-08h],eax; __212 + mov eax,[ebp+010h]; aInstancePtr + push eax + mov ecx,[ebp+0ch]; aIID + mov edx,[ebp+08h]; this + mov edx,[edx+04h] + mov ebx,[ebp-08h]; __212 + mov ebx,[ebx] + mov eax,[ebp-08h]; __212 + add eax,[ebx+024h] + sub esp,0ch + mov ebx,[ebp-08h]; __212 + mov ebx,[ebx] + call dword ptr [ebx+020h] + add esp,010h + mov [ebp-04h],eax; status + +; 97 } else { + jmp @BLBL14 + align 010h +@BLBL13: + +; 95 if ( mServiceManager ) { + +; 98 nsCOMPtr<nsIServiceManager> mgr; + lea eax,[ebp-0ch]; mgr + call __ct__8nsCOMPtrXT17nsIServiceManager_Fv + +; 99 NS_GetServiceManager(getter_AddRefs(mgr)); + lea edx,[ebp-0ch]; mgr + lea eax,[ebp-010h]; __216 + call getter_AddRefs__FR8nsCOMPtrXT17nsIServiceManager_ + sub esp,04h + lea eax,[ebp-010h]; __216 + sub esp,04h + call __opPP17nsIServiceManager__15nsGetterAddRefsXT17nsIServiceManager_Fv + add esp,08h + call NS_GetServiceManager + mov edx,02h + lea eax,[ebp-010h]; __216 + call __dt__15nsGetterAddRefsXT17nsIServiceManager_Fv + +; 100 if (mgr) + lea eax,[ebp-0ch]; mgr + call __opP13nsDerivedSafeXT17nsIServiceManager___8nsCOMPtrXT17nsIServiceManager_CFv + test eax,eax + je @BLBL15 + +; 101 status = mgr->GetService(mCID, aIID, (void**)aInstancePtr); + lea eax,[ebp-0ch]; mgr + call __rf__8nsCOMPtrXT17nsIServiceManager_CFv + mov [ebp-014h],eax; __217 + mov eax,[ebp+010h]; aInstancePtr + push eax + mov ecx,[ebp+0ch]; aIID + mov edx,[ebp+08h]; this + mov edx,[edx+04h] + mov ebx,[ebp-014h]; __217 + mov ebx,[ebx] + mov eax,[ebp-014h]; __217 + add eax,[ebx+024h] + sub esp,0ch + mov ebx,[ebp-014h]; __217 + mov ebx,[ebx] + call dword ptr [ebx+020h] + add esp,010h + mov [ebp-04h],eax; status +@BLBL15: + +; 102 } + mov edx,02h + lea eax,[ebp-0ch]; mgr + call __dt__8nsCOMPtrXT17nsIServiceManager_Fv +@BLBL14: + +; 103 if ( NS_FAILED(status) ) + test byte ptr [ebp-01h],080h; status + je @BLBL16 + +; 104 *aInstancePtr = 0; + mov eax,[ebp+010h]; aInstancePtr + mov dword ptr [eax],0h +@BLBL16: + +; 106 if ( mErrorPtr ) + mov eax,[ebp+08h]; this + cmp dword ptr [eax+0ch],0h + je @BLBL17 + +; 107 *mErrorPtr = status; + mov eax,[ebp+08h]; this + mov eax,[eax+0ch] + mov ebx,[ebp-04h]; status + mov [eax],ebx +@BLBL17: + +; 108 return status; + mov eax,[ebp-04h]; status + add esp,08h + pop ebx + mov esp,ebp + pop ebp + ret +__cl__17nsGetServiceByCIDCFRC4nsIDPPv endp + + * ----- + * C++ Code: +nsresult +nsGetServiceByCID::operator()( const nsIID& aIID, void** aInstancePtr ) const +{ + nsresult status = NS_ERROR_FAILURE; + if ( mServiceManager ) { + status = mServiceManager->GetService(mCID, aIID, (void**)aInstancePtr); + } else { + nsCOMPtr<nsIServiceManager> mgr; + NS_GetServiceManager(getter_AddRefs(mgr)); + if (mgr) + status = mgr->GetService(mCID, aIID, (void**)aInstancePtr); + } + if ( NS_FAILED(status) ) + *aInstancePtr = 0; + + if ( mErrorPtr ) + *mErrorPtr = status; + return status; +} + */ +extern "C" nsresult VFTCALL GSBC_COM__operator_paratheses(void *pvThis, REFNSIID aIID, void** aInstancePtr) +{ + obj_nsGetServiceByCID_nsCOMPtr_helper *pThis = (obj_nsGetServiceByCID_nsCOMPtr_helper *)pvThis; + nsresult status = NS_ERROR_FAILURE; +//asm("int $3"); + + /* For convenience we don't use mServiceManager here because it's a wrapped object. + * We ASSUME that there is only one service manager floating around.... + */ + nsCOMPtr<nsIServiceManager> mgr; + NS_GetServiceManager(getter_AddRefs(mgr)); + if (mgr) + status = mgr->GetService(*pThis->mCID, aIID, (void**)aInstancePtr); + + if (NS_FAILED(status)) + *aInstancePtr = 0; + + if (pThis->mErrorPtr) + *pThis->mErrorPtr = status; + return status; +} + +/** + * Just a destructor. + * ----- + * assembly: +; 59 virtual ~nsGetServiceByCID() {}; + align 010h + +__dt__17nsGetServiceByCIDFv proc + push ebp + mov ebp,esp + sub esp,08h + mov [ebp+08h],eax; this + mov [ebp+0ch],edx; __dtorFlags + mov [ebp+010h],ecx; __vtt + mov eax,[ebp+08h]; this + mov dword ptr [eax],offset FLAT:__vft17nsGetServiceByCID15nsCOMPtr_helper + mov edx,02h + mov eax,[ebp+08h]; this + add eax,08h + call __dt__8nsCOMPtrXT17nsIServiceManager_Fv + test byte ptr [ebp+0ch],01h; __dtorFlags + je @BLBL24 + mov eax,[ebp+08h]; this + call __dl__FPv +@BLBL24: + mov eax,[ebp+08h]; this + add esp,08h + pop ebp + ret +__dt__17nsGetServiceByCIDFv endp + */ +extern "C" void * VFTCALL GSBC_COM__destructor(void *pvThis, unsigned __dtorFlags, unsigned __vtt) +{ + obj_nsGetServiceByCID_nsCOMPtr_helper *pThis = (obj_nsGetServiceByCID_nsCOMPtr_helper *)pvThis; +//asm("int $3"); + + /* + * Because previously mentioned issues with VAC heaps, we'll + * not do anything in here. + * (We will then skip destruction of all parents and such, but + * I don't think that will hurt anyone.) + */ + __dtorFlags = __dtorFlags; + __vtt = __vtt; + return pThis; +} + + +/** + * VFT for nsGetServiceByCID::nsCOMPtr_helper or something like that. + * It's just implementing an operator() and the destructor. + * + * @remark We need to skip an underscore to get the name right. + * ---- + * assembly: +__vft17nsGetServiceByCID15nsCOMPtr_helper dd 0 + db 0h,0h,0h,0h + dd offset FLAT:__cl__17nsGetServiceByCIDCFRC4nsIDPPv + db 0h,0h,0h,0h + dd offset FLAT:__dt__17nsGetServiceByCIDFv + db 0h,0h,0h,0h + */ +extern const VFTnsGetServiceByCID_nsCOMPtr_helper _vft17nsGetServiceByCID15nsCOMPtr_helper = +{ + VFTFIRST_VAL() + GSBC_COM__operator_paratheses, VFTDELTA_VAL() + GSBC_COM__destructor, VFTDELTA_VAL() +}; + + + +/** + * + * ----- + * assembly +; 42 nsQueryInterface::operator()( const nsIID& aIID, void** answer ) const + align 010h + + public __cl__16nsQueryInterfaceCFRC4nsIDPPv +__cl__16nsQueryInterfaceCFRC4nsIDPPv proc + push ebp + mov ebp,esp + sub esp,08h + push ebx + sub esp,0ch + mov [ebp+08h],eax; this + mov [ebp+0ch],edx; aIID + mov [ebp+010h],ecx; answer + +; 45 if ( mRawPtr ) + mov eax,[ebp+08h]; this + cmp dword ptr [eax+04h],0h + je @BLBL1 + +; 46 { +; 47 status = mRawPtr->QueryInterface(aIID, answer); + mov ecx,[ebp+010h]; answer + mov edx,[ebp+0ch]; aIID + mov ebx,[ebp+08h]; this + mov ebx,[ebx+04h] + mov ebx,[ebx] + mov eax,[ebp+08h]; this + mov eax,[eax+04h] + add eax,[ebx+0ch] + mov ebx,[ebp+08h]; this + mov ebx,[ebx+04h] + mov ebx,[ebx] + call dword ptr [ebx+08h] + mov [ebp-04h],eax; status + +; 48 #ifdef NSCAP_FEATURE_TEST_NONNULL_QUERY_SUCCEEDS +; 49 NS_WARN_IF_FALSE(NS_SUCCEEDED(status), "interface not found---were you expecting that?"); +; 50 #endif +; 51 } + jmp @BLBL2 + align 010h +@BLBL1: + +; 45 if ( mRawPtr ) + +; 53 status = NS_ERROR_NULL_POINTER; + mov dword ptr [ebp-04h],080004003h; status +@BLBL2: + +; 55 if ( mErrorPtr ) + mov eax,[ebp+08h]; this + cmp dword ptr [eax+08h],0h + je @BLBL3 + +; 56 *mErrorPtr = status; + mov eax,[ebp+08h]; this + mov eax,[eax+08h] + mov ebx,[ebp-04h]; status + mov [eax],ebx +@BLBL3: + +; 57 return status; + mov eax,[ebp-04h]; status + add esp,0ch + pop ebx + mov esp,ebp + pop ebp + ret +__cl__16nsQueryInterfaceCFRC4nsIDPPv endp + + * ----- + * C++ Code: +nsresult +nsQueryInterface::operator()( const nsIID& aIID, void** answer ) const + { + nsresult status; + if ( mRawPtr ) + { + status = mRawPtr->QueryInterface(aIID, answer); +#ifdef NSCAP_FEATURE_TEST_NONNULL_QUERY_SUCCEEDS + NS_WARN_IF_FALSE(NS_SUCCEEDED(status), "interface not found---were you expecting that?"); +#endif + } + else + status = NS_ERROR_NULL_POINTER; + + if ( mErrorPtr ) + *mErrorPtr = status; + return status; + } + */ +extern "C" nsresult VFTCALL QI_COM__operator_paratheses(void *pvThis, REFNSIID aIID, void** aInstancePtr) +{ + obj_nsQueryInterface_nsCOMPtr_helper *pThis = (obj_nsQueryInterface_nsCOMPtr_helper *)pvThis; + nsresult status = NS_ERROR_NULL_POINTER; +//asm("int $3"); + + if (pThis->mRawPtr) + { + status = pThis->mRawPtr->pVFT->QueryInterface(pThis->mRawPtr, aIID, aInstancePtr); + /* don't care about warnings, do we? */ + } + + if (pThis->mErrorPtr) + *pThis->mErrorPtr = status; + return status; +} + + + +/** + * VFT for nsQueryInterface::nsCOMPtr_helper or something like that. + * No destructor, only an operator(). + * + * @remark We need to skip an underscore to get the name right. + * ----- + * assembly: +__vft16nsQueryInterface15nsCOMPtr_helper dd 0 + db 0h,0h,0h,0h + dd offset FLAT:__cl__16nsQueryInterfaceCFRC4nsIDPPv + db 0h,0h,0h,0h + */ +extern const VFTnsQueryInterface_nsCOMPtr_helper _vft16nsQueryInterface15nsCOMPtr_helper = +{ + VFTFIRST_VAL() + QI_COM__operator_paratheses, VFTDELTA_VAL() +}; + +/** + * + * ----- + * C++ Code: +void +assign_assuming_AddRef( nsISupports* newPtr ) +{ + / * + |AddRef()|ing the new value (before entering this function) before + |Release()|ing the old lets us safely ignore the self-assignment case. + We must, however, be careful only to |Release()| _after_ doing the + assignment, in case the |Release()| leads to our _own_ destruction, + which would, in turn, cause an incorrect second |Release()| of our old + pointer. Thank <waterson@netscape.com> for discovering this. + * / + nsISupports* oldPtr = mRawPtr; + mRawPtr = newPtr; + NSCAP_LOG_ASSIGNMENT(this, newPtr); + NSCAP_LOG_RELEASE(this, oldPtr); + if ( oldPtr ) + NSCAP_RELEASE(this, oldPtr); +} + */ +extern "C" void VFTCALL assign_assuming_AddRef__13nsCOMPtr_baseFP11nsISupports(void *pvThis, obj_nsISupports *newPtr) +{ + obj_nsCOMPtr_base *pThis = (obj_nsCOMPtr_base *)pvThis; + obj_nsISupports *oldPtr; + + oldPtr = pThis->mRawPtr; + pThis->mRawPtr = newPtr; + if (oldPtr) + { + /* NSCAP_RELEASE(this, oldPtr); */ + pThis->mRawPtr->pVFT->Release(oldPtr + oldPtr->pVFT->uDeltaRelease); + } +} + + + + +/** + * + * ----- + * Assembly: +; 77 nsCOMPtr_base::assign_from_helper( const nsCOMPtr_helper& helper, const nsIID& iid ) + align 010h + + public assign_from_helper__13nsCOMPtr_baseFRC15nsCOMPtr_helperRC4nsID +assign_from_helper__13nsCOMPtr_baseFRC15nsCOMPtr_helperRC4nsID proc + push ebp + mov ebp,esp + sub esp,08h + push ebx + sub esp,0ch + mov [ebp+08h],eax; this + mov [ebp+0ch],edx; helper + mov [ebp+010h],ecx; iid + +; 80 if ( NS_FAILED( helper(iid, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) ) + lea ecx,[ebp-04h]; newRawPtr + mov edx,[ebp+010h]; iid + mov ebx,[ebp+0ch]; helper + mov ebx,[ebx] + mov eax,[ebp+0ch]; helper + add eax,[ebx+0ch] + mov ebx,[ebp+0ch]; helper + mov ebx,[ebx] + call dword ptr [ebx+08h] + test eax,080000000h + je @BLBL8 + +; 81 newRawPtr = 0; + mov dword ptr [ebp-04h],0h; newRawPtr +@BLBL8: + +; 82 assign_assuming_AddRef(newRawPtr); + mov edx,[ebp-04h]; newRawPtr + mov eax,[ebp+08h]; this + call assign_assuming_AddRef__13nsCOMPtr_baseFP11nsISupports + add esp,0ch + pop ebx + mov esp,ebp + pop ebp + ret +assign_from_helper__13nsCOMPtr_baseFRC15nsCOMPtr_helperRC4nsID endp + + * ----- + * C Code: +void +nsCOMPtr_base::assign_from_helper( const nsCOMPtr_helper& helper, const nsIID& iid ) + { + nsISupports* newRawPtr; + if ( NS_FAILED( helper(iid, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) ) + newRawPtr = 0; + assign_assuming_AddRef(newRawPtr); + } + */ +extern "C" void VFTCALL assign_from_helper__13nsCOMPtr_baseFRC15nsCOMPtr_helperRC4nsID( + void *pvThis, void * helper, REFNSIID iid) +{ + obj_nsCOMPtr_base *pThis = (obj_nsCOMPtr_base *)pvThis; + obj_nsISupports* newRawPtr = NULL; + nsresult status = NS_ERROR_FAILURE; +//asm("int $3"); + + /* this may or may not be correct but the layout is the same. */ + obj_nsQueryInterface_nsCOMPtr_helper * pHelper = (obj_nsQueryInterface_nsCOMPtr_helper*)helper; + + /* if ( NS_FAILED( helper(iid, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) ) */ + status = pHelper->pVFT->__operator_paratheses((char*)pHelper + pHelper->pVFT->uDelta__operator_paratheses, + iid, (void**)&newRawPtr); + if (NS_FAILED(status)) + newRawPtr = 0; + + /* assign_assuming_AddRef(newRawPtr); */ + assign_assuming_AddRef__13nsCOMPtr_baseFP11nsISupports(pThis, newRawPtr); +} + + + diff --git a/src/libs/xpcom18a4/xpcom/build/nsStringAPI.cpp b/src/libs/xpcom18a4/xpcom/build/nsStringAPI.cpp new file mode 100644 index 00000000..ca9a76e4 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/nsStringAPI.cpp @@ -0,0 +1,261 @@ +/* vim:set ts=2 sw=2 et cindent: */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by IBM Corporation are Copyright (C) 2003 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Darin Fisher <darin@meer.net> + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "nsString.h" +#include "nsCharTraits.h" + +#define NS_STRINGAPI_IMPL +#include "nsStringAPI.h" +#include "nsNativeCharsetUtils.h" + +/* ------------------------------------------------------------------------- */ + +NS_STRINGAPI(nsresult) +NS_StringContainerInit(nsStringContainer &aContainer) +{ + NS_ASSERTION(sizeof(nsStringContainer) >= sizeof(nsString), + "nsStringContainer is not large enough"); + + // use placement new to avoid heap allocating nsString object + new (&aContainer) nsString(); + + return NS_OK; +} + +NS_STRINGAPI(void) +NS_StringContainerFinish(nsStringContainer &aContainer) +{ + // call the nsString dtor + NS_REINTERPRET_CAST(nsString *, &aContainer)->~nsString(); +} + +/* ------------------------------------------------------------------------- */ + +NS_STRINGAPI(PRUint32) +NS_StringGetData(const nsAString &aStr, const PRUnichar **aData, + PRBool *aTerminated) +{ + if (aTerminated) + *aTerminated = aStr.IsTerminated(); + + nsAString::const_iterator begin; + aStr.BeginReading(begin); + *aData = begin.get(); + return begin.size_forward(); +} + +NS_STRINGAPI(PRUnichar *) +NS_StringCloneData(const nsAString &aStr) +{ + return ToNewUnicode(aStr); +} + +NS_STRINGAPI(nsresult) +NS_StringSetData(nsAString &aStr, const PRUnichar *aData, PRUint32 aDataLength) +{ + aStr.Assign(aData, aDataLength); + return NS_OK; // XXX report errors +} + +NS_STRINGAPI(nsresult) +NS_StringSetDataRange(nsAString &aStr, + PRUint32 aCutOffset, PRUint32 aCutLength, + const PRUnichar *aData, PRUint32 aDataLength) +{ + if (aCutOffset == PR_UINT32_MAX) + { + // append case + if (aData) + aStr.Append(aData, aDataLength); + return NS_OK; // XXX report errors + } + + if (aCutLength == PR_UINT32_MAX) + aCutLength = aStr.Length() - aCutOffset; + + if (aData) + { + if (aDataLength == PR_UINT32_MAX) + aStr.Replace(aCutOffset, aCutLength, nsDependentString(aData)); + else + aStr.Replace(aCutOffset, aCutLength, Substring(aData, aData + aDataLength)); + } + else + aStr.Cut(aCutOffset, aCutLength); + + return NS_OK; // XXX report errors +} + +NS_STRINGAPI(nsresult) +NS_StringCopy(nsAString &aDest, const nsAString &aSrc) +{ + aDest.Assign(aSrc); + return NS_OK; // XXX report errors +} + +/* ------------------------------------------------------------------------- */ + +NS_STRINGAPI(nsresult) +NS_CStringContainerInit(nsCStringContainer &aContainer) +{ + NS_ASSERTION(sizeof(nsCStringContainer) >= sizeof(nsCString), + "nsCStringContainer is not large enough"); + + // use placement new to avoid heap allocating nsCString object + new (&aContainer) nsCString(); + + return NS_OK; +} + +NS_STRINGAPI(void) +NS_CStringContainerFinish(nsCStringContainer &aContainer) +{ + // call the nsCString dtor + NS_REINTERPRET_CAST(nsCString *, &aContainer)->~nsCString(); +} + +/* ------------------------------------------------------------------------- */ + +NS_STRINGAPI(PRUint32) +NS_CStringGetData(const nsACString &aStr, const char **aData, + PRBool *aTerminated) +{ + if (aTerminated) + *aTerminated = aStr.IsTerminated(); + + nsACString::const_iterator begin; + aStr.BeginReading(begin); + *aData = begin.get(); + return begin.size_forward(); +} + +NS_STRINGAPI(char *) +NS_CStringCloneData(const nsACString &aStr) +{ + return ToNewCString(aStr); +} + +NS_STRINGAPI(nsresult) +NS_CStringSetData(nsACString &aStr, const char *aData, PRUint32 aDataLength) +{ + aStr.Assign(aData, aDataLength); + return NS_OK; // XXX report errors +} + +NS_STRINGAPI(nsresult) +NS_CStringSetDataRange(nsACString &aStr, + PRUint32 aCutOffset, PRUint32 aCutLength, + const char *aData, PRUint32 aDataLength) +{ + if (aCutOffset == PR_UINT32_MAX) + { + // append case + if (aData) + aStr.Append(aData, aDataLength); + return NS_OK; // XXX report errors + } + + if (aCutLength == PR_UINT32_MAX) + aCutLength = aStr.Length() - aCutOffset; + + if (aData) + { + if (aDataLength == PR_UINT32_MAX) + aStr.Replace(aCutOffset, aCutLength, nsDependentCString(aData)); + else + aStr.Replace(aCutOffset, aCutLength, Substring(aData, aData + aDataLength)); + } + else + aStr.Cut(aCutOffset, aCutLength); + + return NS_OK; // XXX report errors +} + +NS_STRINGAPI(nsresult) +NS_CStringCopy(nsACString &aDest, const nsACString &aSrc) +{ + aDest.Assign(aSrc); + return NS_OK; // XXX report errors +} + +/* ------------------------------------------------------------------------- */ + +NS_STRINGAPI(nsresult) +NS_CStringToUTF16(const nsACString &aSrc, + nsCStringEncoding aSrcEncoding, + nsAString &aDest) +{ + switch (aSrcEncoding) + { + case NS_CSTRING_ENCODING_ASCII: + CopyASCIItoUTF16(aSrc, aDest); + break; + case NS_CSTRING_ENCODING_UTF8: + CopyUTF8toUTF16(aSrc, aDest); + break; + case NS_CSTRING_ENCODING_NATIVE_FILESYSTEM: + NS_CopyNativeToUnicode(aSrc, aDest); + break; + default: + return NS_ERROR_NOT_IMPLEMENTED; + } + + return NS_OK; // XXX report errors +} + +NS_STRINGAPI(nsresult) +NS_UTF16ToCString(const nsAString &aSrc, + nsCStringEncoding aDestEncoding, + nsACString &aDest) +{ + switch (aDestEncoding) + { + case NS_CSTRING_ENCODING_ASCII: + LossyCopyUTF16toASCII(aSrc, aDest); + break; + case NS_CSTRING_ENCODING_UTF8: + CopyUTF16toUTF8(aSrc, aDest); + break; + case NS_CSTRING_ENCODING_NATIVE_FILESYSTEM: + NS_CopyUnicodeToNative(aSrc, aDest); + break; + default: + return NS_ERROR_NOT_IMPLEMENTED; + } + + return NS_OK; // XXX report errors +} diff --git a/src/libs/xpcom18a4/xpcom/build/nsXPCOM.h b/src/libs/xpcom18a4/xpcom/build/nsXPCOM.h new file mode 100644 index 00000000..4e60c74e --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/nsXPCOM.h @@ -0,0 +1,217 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nsXPCOM_h__ +#define nsXPCOM_h__ + +#include "nscore.h" +#include "nsXPCOMCID.h" + +#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP +#define NS_InitXPCOM2 VBoxNsxpNS_InitXPCOM2 +#define NS_ShutdownXPCOM VBoxNsxpNS_ShutdownXPCOM +#define NS_NewNativeLocalFile VBoxNsxpNS_NewNativeLocalFile +#define NS_GetServiceManager VBoxNsxpNS_GetServiceManager +#define NS_GetComponentManager VBoxNsxpNS_GetComponentManager +#define NS_GetComponentRegistrar VBoxNsxpNS_GetComponentRegistrar +#define NS_GetDebug VBoxNsxpNS_GetDebug +#define NS_GetMemoryManager VBoxNsxpNS_GetMemoryManager +#define NS_GetTraceRefcnt VBoxNsxpNS_GetTraceRefcnt +#define NS_NewLocalFile VBoxNsxpNS_NewLocalFile +#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + +class nsAString; +class nsACString; + +class nsIComponentManager; +class nsIComponentRegistrar; +class nsIServiceManager; +class nsIFile; +class nsILocalFile; +class nsIDirectoryServiceProvider; +class nsIMemory; +class nsIDebug; +class nsITraceRefcnt; + +/** + * Initialises XPCOM. You must call this method before proceeding + * to use xpcom. The one exception is that you may call + * NS_NewLocalFile to create a nsIFile. + * + * @status FROZEN + * + * @note Use <CODE>NS_NewLocalFile</CODE> or <CODE>NS_NewNativeLocalFile</CODE> + * to create the file object you supply as the bin directory path in this + * call. The function may be safely called before the rest of XPCOM or + * embedding has been initialised. + * + * @param result The service manager. You may pass null. + * + * @param binDirectory The directory containing the component + * registry and runtime libraries; + * or use <CODE>nsnull</CODE> to use the working + * directory. + * + * @param appFileLocationProvider The object to be used by Gecko that specifies + * to Gecko where to find profiles, the component + * registry preferences and so on; or use + * <CODE>nsnull</CODE> for the default behaviour. + * + * @see NS_NewLocalFile + * @see nsILocalFile + * @see nsIDirectoryServiceProvider + * + * @return NS_OK for success; + * NS_ERROR_NOT_INITIALIZED if static globals were not initialied, which + * can happen if XPCOM is reloaded, but did not completly shutdown. + * other error codes indicate a failure during initialisation. + * + */ +extern "C" NS_COM nsresult +NS_InitXPCOM2(nsIServiceManager* *result, + nsIFile* binDirectory, + nsIDirectoryServiceProvider* appFileLocationProvider); +/** + * Shutdown XPCOM. You must call this method after you are finished + * using xpcom. + * + * @status FROZEN + * + * @param servMgr The service manager which was returned by NS_InitXPCOM2. + * This will release servMgr. You may pass null. + * + * @return NS_OK for success; + * other error codes indicate a failure during initialisation. + * + */ +extern "C" NS_COM nsresult +NS_ShutdownXPCOM(nsIServiceManager* servMgr); + + +/** + * Public Method to access to the service manager. + * + * @status FROZEN + * @param result Interface pointer to the service manager + * + * @return NS_OK for success; + * other error codes indicate a failure during initialisation. + * + */ +extern "C" NS_COM nsresult +NS_GetServiceManager(nsIServiceManager* *result); + +/** + * Public Method to access to the component manager. + * + * @status FROZEN + * @param result Interface pointer to the service + * + * @return NS_OK for success; + * other error codes indicate a failure during initialisation. + * + */ +extern "C" NS_COM nsresult +NS_GetComponentManager(nsIComponentManager* *result); + +/** + * Public Method to access to the component registration manager. + * + * @status FROZEN + * @param result Interface pointer to the service + * + * @return NS_OK for success; + * other error codes indicate a failure during initialisation. + * + */ +extern "C" NS_COM nsresult +NS_GetComponentRegistrar(nsIComponentRegistrar* *result); + +/** + * Public Method to access to the memory manager. See nsIMemory + * + * @status FROZEN + * @param result Interface pointer to the memory manager + * + * @return NS_OK for success; + * other error codes indicate a failure during initialisation. + * + */ +extern "C" NS_COM nsresult +NS_GetMemoryManager(nsIMemory* *result); + +/** + * Public Method to create an instance of a nsILocalFile. This function + * may be called prior to NS_InitXPCOM2. + * + * @status FROZEN + * + * @param path + * A string which specifies a full file path to a + * location. Relative paths will be treated as an + * error (NS_ERROR_FILE_UNRECOGNIZED_PATH). + * |NS_NewNativeLocalFile|'s path must be in the + * filesystem charset. + * @param followLinks + * This attribute will determine if the nsLocalFile will auto + * resolve symbolic links. By default, this value will be false + * on all non unix systems. On unix, this attribute is effectively + * a noop. + * @param result Interface pointer to a new instance of an nsILocalFile + * + * @return NS_OK for success; + * other error codes indicate a failure. + */ + +extern "C" NS_COM nsresult +NS_NewLocalFile(const nsAString &path, + PRBool followLinks, + nsILocalFile* *result); + +extern "C" NS_COM nsresult +NS_NewNativeLocalFile(const nsACString &path, + PRBool followLinks, + nsILocalFile* *result); + + +extern "C" NS_COM nsresult +NS_GetDebug(nsIDebug* *result); + +extern "C" NS_COM nsresult +NS_GetTraceRefcnt(nsITraceRefcnt* *result); + +#endif diff --git a/src/libs/xpcom18a4/xpcom/build/nsXPCOMCID.h b/src/libs/xpcom18a4/xpcom/build/nsXPCOMCID.h new file mode 100644 index 00000000..d5bd039c --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/nsXPCOMCID.h @@ -0,0 +1,174 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nsXPCOMCID_h__ +#define nsXPCOMCID_h__ + +/** + * XPCOM Directory Service Contract ID + * The directory service provides ways to obtain file system locations. The + * directory service is a singleton. + * + * This contract supports the nsIDirectoryService and the nsIProperties + * interfaces. + * + */ +#define NS_DIRECTORY_SERVICE_CONTRACTID "@mozilla.org/file/directory_service;1" + +/** + * XPCOM File + * The file abstraction provides ways to obtain and access files and + * directories located on the local system. + * + * This contract supports the nsIFile interface and the nsILocalFile interface. + * This contract may also support platform specific interfaces such as + * nsILocalFileMac on platforms where additional interfaces are required. + * + */ +#define NS_LOCAL_FILE_CONTRACTID "@mozilla.org/file/local;1" + +/** + * XPCOM Category Manager Contract ID + * The contract supports the nsICategoryManager interface. The + * category manager is a singleton. + */ +#define NS_CATEGORYMANAGER_CONTRACTID "@mozilla.org/categorymanager;1" + +/** + * XPCOM Properties Object Contract ID + * Simple mapping object which supports the nsIProperties interface. + */ +#define NS_PROPERTIES_CONTRACTID "@mozilla.org/properties;1" + +/** + * XPCOM Array Object ContractID + * Simple array implementation which supports the nsIArray and + * nsIMutableArray interfaces. + */ +#define NS_ARRAY_CONTRACTID "@mozilla.org/array;1" + +/** + * The following are the CIDs and Contract IDs of the nsISupports wrappers for + * primative types. + */ +#define NS_SUPPORTS_ID_CID \ +{ 0xacf8dc40, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_ID_CONTRACTID "@mozilla.org/supports-id;1" + +#define NS_SUPPORTS_CSTRING_CID \ +{ 0xacf8dc41, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_CSTRING_CONTRACTID "@mozilla.org/supports-cstring;1" + +#define NS_SUPPORTS_STRING_CID \ +{ 0xacf8dc42, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_STRING_CONTRACTID "@mozilla.org/supports-string;1" + +#define NS_SUPPORTS_PRBOOL_CID \ +{ 0xacf8dc43, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRBOOL_CONTRACTID "@mozilla.org/supports-PRBool;1" + +#define NS_SUPPORTS_PRUINT8_CID \ +{ 0xacf8dc44, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRUINT8_CONTRACTID "@mozilla.org/supports-PRUint8;1" + +#define NS_SUPPORTS_PRUINT16_CID \ +{ 0xacf8dc46, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRUINT16_CONTRACTID "@mozilla.org/supports-PRUint16;1" + +#define NS_SUPPORTS_PRUINT32_CID \ +{ 0xacf8dc47, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRUINT32_CONTRACTID "@mozilla.org/supports-PRUint32;1" + +#define NS_SUPPORTS_PRUINT64_CID \ +{ 0xacf8dc48, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRUINT64_CONTRACTID "@mozilla.org/supports-PRUint64;1" + +#define NS_SUPPORTS_PRTIME_CID \ +{ 0xacf8dc49, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRTIME_CONTRACTID "@mozilla.org/supports-PRTime;1" + +#define NS_SUPPORTS_CHAR_CID \ +{ 0xacf8dc4a, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_CHAR_CONTRACTID "@mozilla.org/supports-char;1" + +#define NS_SUPPORTS_PRINT16_CID \ +{ 0xacf8dc4b, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRINT16_CONTRACTID "@mozilla.org/supports-PRInt16;1" + +#define NS_SUPPORTS_PRINT32_CID \ +{ 0xacf8dc4c, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRINT32_CONTRACTID "@mozilla.org/supports-PRInt32;1" + +#define NS_SUPPORTS_PRINT64_CID \ +{ 0xacf8dc4d, 0x4a25, 0x11d3, \ +{ 0x98, 0x90, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } } +#define NS_SUPPORTS_PRINT64_CONTRACTID "@mozilla.org/supports-PRInt64;1" + +#define NS_SUPPORTS_FLOAT_CID \ +{ 0xcbf86870, 0x4ac0, 0x11d3, \ +{ 0xba, 0xea, 0x0, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 } } +#define NS_SUPPORTS_FLOAT_CONTRACTID "@mozilla.org/supports-float;1" + +#define NS_SUPPORTS_DOUBLE_CID \ +{ 0xcbf86871, 0x4ac0, 0x11d3, \ +{ 0xba, 0xea, 0x0, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 } } +#define NS_SUPPORTS_DOUBLE_CONTRACTID "@mozilla.org/supports-double;1" + +#define NS_SUPPORTS_VOID_CID \ +{ 0xaf10f3e0, 0x568d, 0x11d3, \ +{ 0xba, 0xf8, 0x0, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 } } +#define NS_SUPPORTS_VOID_CONTRACTID "@mozilla.org/supports-void;1" + +#define NS_SUPPORTS_INTERFACE_POINTER_CID \ +{ 0xA99FEBBA, 0x1DD1, 0x11B2, \ +{ 0xA9, 0x43, 0xB0, 0x23, 0x34, 0xA6, 0xD0, 0x83 } } +#define NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID "@mozilla.org/supports-interface-pointer;1" + + +#endif diff --git a/src/libs/xpcom18a4/xpcom/build/nsXPCOMPrivate.h b/src/libs/xpcom18a4/xpcom/build/nsXPCOMPrivate.h new file mode 100644 index 00000000..cd526ba3 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/nsXPCOMPrivate.h @@ -0,0 +1,228 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim:set ts=4 sw=4 et cindent: */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nsXPComPrivate_h__ +#define nsXPComPrivate_h__ + +#include "nscore.h" +#include "nsXPCOM.h" + +class nsStringContainer; +class nsCStringContainer; + +#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP +#define NS_GetFrozenFunctions VBoxNsxpNS_GetFrozenFunctions +#define NS_RegisterXPCOMExitRoutine VBoxNsxpNS_RegisterXPCOMExitRoutine +#define NS_UnregisterXPCOMExitRoutine VBoxNsxpNS_UnregisterXPCOMExitRoutine +#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + +/** + * Private Method to register an exit routine. This method + * allows you to setup a callback that will be called from + * the NS_ShutdownXPCOM function after all services and + * components have gone away. + * + * This API is for the exclusive use of the xpcom glue library. + * + * Note that these APIs are NOT threadsafe and must be called on the + * main thread. + * + * @status FROZEN + * @param exitRoutine pointer to user defined callback function + * of type XPCOMExitRoutine. + * @param priority higher priorities are called before lower + * priorities. + * + * @return NS_OK for success; + * other error codes indicate a failure. + * + */ +typedef NS_CALLBACK(XPCOMExitRoutine)(void); + +extern "C" NS_COM nsresult +NS_RegisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine, PRUint32 priority); + +extern "C" NS_COM nsresult +NS_UnregisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine); + + +// PUBLIC +typedef nsresult (* InitFunc)(nsIServiceManager* *result, nsIFile* binDirectory, nsIDirectoryServiceProvider* appFileLocationProvider); +typedef nsresult (* ShutdownFunc)(nsIServiceManager* servMgr); +typedef nsresult (* GetServiceManagerFunc)(nsIServiceManager* *result); +typedef nsresult (* GetComponentManagerFunc)(nsIComponentManager* *result); +typedef nsresult (* GetComponentRegistrarFunc)(nsIComponentRegistrar* *result); +typedef nsresult (* GetMemoryManagerFunc)(nsIMemory* *result); +typedef nsresult (* NewLocalFileFunc)(const nsAString &path, PRBool followLinks, nsILocalFile* *result); +typedef nsresult (* NewNativeLocalFileFunc)(const nsACString &path, PRBool followLinks, nsILocalFile* *result); + +typedef nsresult (* GetDebugFunc)(nsIDebug* *result); +typedef nsresult (* GetTraceRefcntFunc)(nsITraceRefcnt* *result); + +typedef nsresult (* StringContainerInitFunc)(nsStringContainer&); +typedef void (* StringContainerFinishFunc)(nsStringContainer&); +typedef PRUint32 (* StringGetDataFunc)(const nsAString&, const PRUnichar**, PRBool*); +typedef PRUnichar* (* StringCloneDataFunc)(const nsAString&); +typedef nsresult (* StringSetDataFunc)(nsAString&, const PRUnichar*, PRUint32); +typedef nsresult (* StringSetDataRangeFunc)(nsAString&, PRUint32, PRUint32, const PRUnichar*, PRUint32); +typedef nsresult (* StringCopyFunc)(nsAString &, const nsAString &); + +typedef nsresult (* CStringContainerInitFunc)(nsCStringContainer&); +typedef void (* CStringContainerFinishFunc)(nsCStringContainer&); +typedef PRUint32 (* CStringGetDataFunc)(const nsACString&, const char**, PRBool*); +typedef char* (* CStringCloneDataFunc)(const nsACString&); +typedef nsresult (* CStringSetDataFunc)(nsACString&, const char*, PRUint32); +typedef nsresult (* CStringSetDataRangeFunc)(nsACString&, PRUint32, PRUint32, const char*, PRUint32); +typedef nsresult (* CStringCopyFunc)(nsACString &, const nsACString &); + +typedef nsresult (* CStringToUTF16)(const nsACString &, PRUint32, const nsAString &); +typedef nsresult (* UTF16ToCString)(const nsAString &, PRUint32, const nsACString &); + +// PRIVATE +typedef nsresult (* RegisterXPCOMExitRoutineFunc)(XPCOMExitRoutine exitRoutine, PRUint32 priority); +typedef nsresult (* UnregisterXPCOMExitRoutineFunc)(XPCOMExitRoutine exitRoutine); + +typedef struct XPCOMFunctions{ + PRUint32 version; + PRUint32 size; + + InitFunc init; + ShutdownFunc shutdown; + GetServiceManagerFunc getServiceManager; + GetComponentManagerFunc getComponentManager; + GetComponentRegistrarFunc getComponentRegistrar; + GetMemoryManagerFunc getMemoryManager; + NewLocalFileFunc newLocalFile; + NewNativeLocalFileFunc newNativeLocalFile; + + RegisterXPCOMExitRoutineFunc registerExitRoutine; + UnregisterXPCOMExitRoutineFunc unregisterExitRoutine; + + // Added for Mozilla 1.5 + GetDebugFunc getDebug; + GetTraceRefcntFunc getTraceRefcnt; + + // Added for Mozilla 1.7 + StringContainerInitFunc stringContainerInit; + StringContainerFinishFunc stringContainerFinish; + StringGetDataFunc stringGetData; + StringSetDataFunc stringSetData; + StringSetDataRangeFunc stringSetDataRange; + StringCopyFunc stringCopy; + CStringContainerInitFunc cstringContainerInit; + CStringContainerFinishFunc cstringContainerFinish; + CStringGetDataFunc cstringGetData; + CStringSetDataFunc cstringSetData; + CStringSetDataRangeFunc cstringSetDataRange; + CStringCopyFunc cstringCopy; + CStringToUTF16 cstringToUTF16; + UTF16ToCString utf16ToCString; + StringCloneDataFunc stringCloneData; + CStringCloneDataFunc cstringCloneData; + +} XPCOMFunctions; + +typedef nsresult (PR_CALLBACK *GetFrozenFunctionsFunc)(XPCOMFunctions *entryPoints, const char* libraryPath); +extern "C" NS_COM nsresult +NS_GetFrozenFunctions(XPCOMFunctions *entryPoints, const char* libraryPath); + +// think hard before changing this +#define XPCOM_GLUE_VERSION 1 + + +/* XPCOM Specific Defines + * + * XPCOM_DLL - name of the loadable xpcom library on disk. + * XPCOM_SEARCH_KEY - name of the environment variable that can be + * modified to include additional search paths. + * GRE_CONF_NAME - Name of the GRE Configuration file + */ + +#ifdef XPCOM_DLL_BASE +#define XPCOM_DLL XPCOM_DLL_BASE MOZ_DLL_SUFFIX +#endif + +#if defined(XP_WIN32) || defined(XP_OS2) + +#define XPCOM_SEARCH_KEY "PATH" +#define GRE_CONF_NAME "gre.config" +#define GRE_WIN_REG_LOC "Software\\mozilla.org\\GRE\\" +#ifndef XPCOM_DLL +#define XPCOM_DLL "xpcom"MOZ_DLL_SUFFIX +#endif + +#elif defined(XP_BEOS) + +#define XPCOM_SEARCH_KEY "ADDON_PATH" +#define GRE_CONF_NAME ".gre.config" +#define GRE_CONF_PATH "/boot/home/config/settings/GRE/gre.conf" +#ifndef XPCOM_DLL +#define XPCOM_DLL "libxpcom"MOZ_DLL_SUFFIX +#endif + +#else // Unix + +#ifndef XPCOM_DLL +#define XPCOM_DLL "libxpcom"MOZ_DLL_SUFFIX +#endif + +// you have to love apple.. +#ifdef XP_MACOSX +#define XPCOM_SEARCH_KEY "DYLD_LIBRARY_PATH" +#else +#define XPCOM_SEARCH_KEY "LD_LIBRARY_PATH" +#endif + +#define GRE_CONF_NAME ".gre.config" +#define GRE_CONF_PATH "/etc/gre.conf" +#define GRE_CONF_DIR "/etc/gre.d/" +#endif + +#if defined(XP_WIN) || defined(XP_OS2) + #define XPCOM_FILE_PATH_SEPARATOR "\\" + #define XPCOM_ENV_PATH_SEPARATOR ";" +#elif defined(XP_UNIX) || defined(XP_BEOS) + #define XPCOM_FILE_PATH_SEPARATOR "/" + #define XPCOM_ENV_PATH_SEPARATOR ":" +#else + #error need_to_define_your_file_path_separator_and_illegal_characters +#endif + +#endif + + diff --git a/src/libs/xpcom18a4/xpcom/build/nsXPComInit.cpp b/src/libs/xpcom18a4/xpcom/build/nsXPComInit.cpp new file mode 100644 index 00000000..65d84b6b --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/nsXPComInit.cpp @@ -0,0 +1,1079 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "nsXPCOM.h" +#include "nsXPCOMPrivate.h" +#include "nscore.h" +#include "prlink.h" +#include "nsCOMPtr.h" +#include "nsObserverList.h" +#include "nsObserverService.h" +#include "nsProperties.h" +#include "nsIProperties.h" +#include "nsPersistentProperties.h" +#include "nsScriptableInputStream.h" +#include "nsBinaryStream.h" +#include "nsStorageStream.h" + +#include "nsMemoryImpl.h" +#include "nsDebugImpl.h" +#include "nsTraceRefcntImpl.h" +#include "nsErrorService.h" +#include "nsByteBuffer.h" + +#include "nsSupportsArray.h" +#include "nsArray.h" +#include "nsSupportsPrimitives.h" +#include "nsConsoleService.h" +#include "nsExceptionService.h" + +#include "nsComponentManager.h" +#include "nsCategoryManagerUtils.h" +#include "nsIServiceManager.h" +#include "nsGenericFactory.h" + +#include "nsEventQueueService.h" +#include "nsEventQueue.h" +#ifdef VBOX +# include "nsEventQueueUtils.h" +# include "nsProxyRelease.h" +#endif /* VBOX */ + +#include "nsIProxyObjectManager.h" +#include "nsProxyEventPrivate.h" // access to the impl of nsProxyObjectManager for the generic factory registration. + +#include "xptinfo.h" +#include "nsIInterfaceInfoManager.h" + +#include "nsTimerImpl.h" +#include "TimerThread.h" + +#include "nsThread.h" +#include "nsProcess.h" +#include "nsEnvironment.h" + +#include "nsEmptyEnumerator.h" + +#include "nsILocalFile.h" +#include "nsLocalFile.h" +#if defined(XP_UNIX) || defined(XP_OS2) +#include "nsNativeCharsetUtils.h" +#endif +#include "nsDirectoryService.h" +#include "nsDirectoryServiceDefs.h" +#include "nsCategoryManager.h" +#include "nsICategoryManager.h" +#include "nsStringStream.h" +#include "nsMultiplexInputStream.h" + +#include "nsFastLoadService.h" + +#include "nsAtomService.h" +#include "nsAtomTable.h" +#include "nsTraceRefcnt.h" +#include "nsTimelineService.h" + +#include "nsVariant.h" + +#ifdef GC_LEAK_DETECTOR +#include "nsLeakDetector.h" +#endif +#include "nsRecyclingAllocator.h" + +#include "SpecialSystemDirectory.h" + +#include "ipcdclient.h" +#include "ipcService.h" +#include "ipcConfig.h" +#include "ipcCID.h" +#include "ipcLockService.h" +#include "ipcLockCID.h" +#include "tmTransactionService.h" +#include "ipcDConnectService.h" + +#include <locale.h> + +// Registry Factory creation function defined in nsRegistry.cpp +// We hook into this function locally to create and register the registry +// Since noone outside xpcom needs to know about this and nsRegistry.cpp +// does not have a local include file, we are putting this definition +// here rather than in nsIRegistry.h +extern nsresult NS_RegistryGetFactory(nsIFactory** aFactory); +extern nsresult NS_CategoryManagerGetFactory( nsIFactory** ); + +#ifdef DEBUG +extern void _FreeAutoLockStatics(); +#endif + +static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID); +static NS_DEFINE_CID(kMemoryCID, NS_MEMORY_CID); +static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID); + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsProcess) +NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsEventQueueServiceImpl, Init) + +#define NS_ENVIRONMENT_CLASSNAME "Environment Service" + +#include "nsXPCOM.h" +// ds/nsISupportsPrimitives +#define NS_SUPPORTS_ID_CLASSNAME "Supports ID" +#define NS_SUPPORTS_CSTRING_CLASSNAME "Supports String" +#define NS_SUPPORTS_STRING_CLASSNAME "Supports WString" +#define NS_SUPPORTS_PRBOOL_CLASSNAME "Supports PRBool" +#define NS_SUPPORTS_PRUINT8_CLASSNAME "Supports PRUint8" +#define NS_SUPPORTS_PRUINT16_CLASSNAME "Supports PRUint16" +#define NS_SUPPORTS_PRUINT32_CLASSNAME "Supports PRUint32" +#define NS_SUPPORTS_PRUINT64_CLASSNAME "Supports PRUint64" +#define NS_SUPPORTS_PRTIME_CLASSNAME "Supports PRTime" +#define NS_SUPPORTS_CHAR_CLASSNAME "Supports Char" +#define NS_SUPPORTS_PRINT16_CLASSNAME "Supports PRInt16" +#define NS_SUPPORTS_PRINT32_CLASSNAME "Supports PRInt32" +#define NS_SUPPORTS_PRINT64_CLASSNAME "Supports PRInt64" +#define NS_SUPPORTS_FLOAT_CLASSNAME "Supports float" +#define NS_SUPPORTS_DOUBLE_CLASSNAME "Supports double" +#define NS_SUPPORTS_VOID_CLASSNAME "Supports void" +#define NS_SUPPORTS_INTERFACE_POINTER_CLASSNAME "Supports interface pointer" + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsIDImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsStringImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsCStringImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRBoolImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint8Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint16Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint32Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRUint64Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRTimeImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsCharImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRInt16Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRInt32Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsPRInt64Impl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsFloatImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsDoubleImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsVoidImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsSupportsInterfacePointerImpl) + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsArray) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsConsoleService) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsAtomService) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsExceptionService) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsTimerImpl) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsTimerManager) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsBinaryOutputStream) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsBinaryInputStream) +NS_GENERIC_FACTORY_CONSTRUCTOR(nsStorageStream) + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsVariant) + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsRecyclingAllocatorImpl) + +#ifdef MOZ_TIMELINE +NS_GENERIC_FACTORY_CONSTRUCTOR(nsTimelineService) +#endif + +static NS_METHOD +nsXPTIInterfaceInfoManagerGetSingleton(nsISupports* outer, + const nsIID& aIID, + void* *aInstancePtr) +{ + NS_ENSURE_ARG_POINTER(aInstancePtr); + NS_ENSURE_TRUE(!outer, NS_ERROR_NO_AGGREGATION); + + nsCOMPtr<nsIInterfaceInfoManager> iim(dont_AddRef(XPTI_GetInterfaceInfoManager())); + if (!iim) { + return NS_ERROR_FAILURE; + } + + return iim->QueryInterface(aIID, aInstancePtr); +} + + +PR_STATIC_CALLBACK(nsresult) +RegisterGenericFactory(nsIComponentRegistrar* registrar, + const nsModuleComponentInfo *info) +{ + nsresult rv; + nsIGenericFactory* fact; + rv = NS_NewGenericFactory(&fact, info); + if (NS_FAILED(rv)) return rv; + + rv = registrar->RegisterFactory(info->mCID, + info->mDescription, + info->mContractID, + fact); + NS_RELEASE(fact); + return rv; +} + +// In order to support the installer, we need +// to be told out of band if we should cause +// an autoregister. If the file ".autoreg" exists in the binary +// directory, we check its timestamp against the timestamp of the +// compreg.dat file. If the .autoreg file is newer, we autoregister. +static PRBool CheckUpdateFile() +{ + nsresult rv; + nsCOMPtr<nsIProperties> directoryService; + nsDirectoryService::Create(nsnull, + NS_GET_IID(nsIProperties), + getter_AddRefs(directoryService)); + + if (!directoryService) + return PR_FALSE; + + nsCOMPtr<nsIFile> file; + rv = directoryService->Get(NS_XPCOM_CURRENT_PROCESS_DIR, + NS_GET_IID(nsIFile), + getter_AddRefs(file)); + + if (NS_FAILED(rv)) { + NS_WARNING("Getting NS_XPCOM_CURRENT_PROCESS_DIR failed"); + return PR_FALSE; + } + + file->AppendNative(nsDependentCString(".autoreg")); + + PRBool exists; + file->Exists(&exists); + if (!exists) + return PR_FALSE; + + nsCOMPtr<nsIFile> compregFile; + rv = directoryService->Get(NS_XPCOM_COMPONENT_REGISTRY_FILE, + NS_GET_IID(nsIFile), + getter_AddRefs(compregFile)); + + + if (NS_FAILED(rv)) { + NS_WARNING("Getting NS_XPCOM_COMPONENT_REGISTRY_FILE failed"); + return PR_FALSE; + } + + // Don't need to check whether compreg exists; if it doesn't + // we won't even be here. + + PRInt64 compregModTime, autoregModTime; + compregFile->GetLastModifiedTime(&compregModTime); + file->GetLastModifiedTime(&autoregModTime); + + return LL_CMP(autoregModTime, >, compregModTime); +} + +#if 0 /// @todo later +NS_GENERIC_FACTORY_CONSTRUCTOR(ipcService) +NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(ipcLockService, Init) +NS_GENERIC_FACTORY_CONSTRUCTOR(tmTransactionService) +NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(ipcDConnectService, Init) + +// enable this code to make the IPC DCONNECT service auto-start. +NS_METHOD +ipcDConnectServiceRegisterProc(nsIComponentManager *aCompMgr, + nsIFile *aPath, + const char *registryLocation, + const char *componentType, + const nsModuleComponentInfo *info) +{ + // + // add ipcService to the XPCOM startup category + // + nsCOMPtr<nsICategoryManager> catman(do_GetService(NS_CATEGORYMANAGER_CONTRACTID)); + if (catman) { + nsXPIDLCString prevEntry; + catman->AddCategoryEntry(NS_XPCOM_STARTUP_OBSERVER_ID, "ipcDConnectService", + IPC_DCONNECTSERVICE_CONTRACTID, PR_TRUE, PR_TRUE, + getter_Copies(prevEntry)); + } + return NS_OK; +} + +NS_METHOD +ipcDConnectServiceUnregisterProc(nsIComponentManager *aCompMgr, + nsIFile *aPath, + const char *registryLocation, + const nsModuleComponentInfo *info) +{ + nsCOMPtr<nsICategoryManager> catman(do_GetService(NS_CATEGORYMANAGER_CONTRACTID)); + if (catman) + catman->DeleteCategoryEntry(NS_XPCOM_STARTUP_OBSERVER_ID, + IPC_DCONNECTSERVICE_CONTRACTID, PR_TRUE); + return NS_OK; +} +#endif + +nsComponentManagerImpl* nsComponentManagerImpl::gComponentManager = NULL; +nsIProperties *gDirectoryService = NULL; +PRBool gXPCOMShuttingDown = PR_FALSE; + +// For each class that wishes to support nsIClassInfo, add a line like this +// NS_DECL_CLASSINFO(nsMyClass) + +#define COMPONENT(NAME, Ctor) \ + { NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor } + +#define COMPONENT_CI(NAME, Ctor, Class) \ + { NS_##NAME##_CLASSNAME, NS_##NAME##_CID, NS_##NAME##_CONTRACTID, Ctor, \ + NULL, NULL, NULL, NS_CI_INTERFACE_GETTER_NAME(Class), NULL, \ + &NS_CLASSINFO_NAME(Class) } + +static const nsModuleComponentInfo components[] = { + COMPONENT(MEMORY, nsMemoryImpl::Create), + COMPONENT(DEBUG, nsDebugImpl::Create), +#define NS_ERRORSERVICE_CLASSNAME NS_ERRORSERVICE_NAME + COMPONENT(ERRORSERVICE, nsErrorService::Create), + + COMPONENT(BYTEBUFFER, ByteBufferImpl::Create), + COMPONENT(SCRIPTABLEINPUTSTREAM, nsScriptableInputStream::Create), + COMPONENT(BINARYINPUTSTREAM, nsBinaryInputStreamConstructor), + COMPONENT(BINARYOUTPUTSTREAM, nsBinaryOutputStreamConstructor), + COMPONENT(STORAGESTREAM, nsStorageStreamConstructor), + +#define NS_PROPERTIES_CLASSNAME "Properties" + COMPONENT(PROPERTIES, nsProperties::Create), + +#define NS_PERSISTENTPROPERTIES_CID NS_IPERSISTENTPROPERTIES_CID /* sigh */ + COMPONENT(PERSISTENTPROPERTIES, nsPersistentProperties::Create), + + COMPONENT(SUPPORTSARRAY, nsSupportsArray::Create), + COMPONENT(ARRAY, nsArrayConstructor), + COMPONENT(CONSOLESERVICE, nsConsoleServiceConstructor), + COMPONENT(EXCEPTIONSERVICE, nsExceptionServiceConstructor), + COMPONENT(ATOMSERVICE, nsAtomServiceConstructor), +#ifdef MOZ_TIMELINE + COMPONENT(TIMELINESERVICE, nsTimelineServiceConstructor), +#endif + COMPONENT(OBSERVERSERVICE, nsObserverService::Create), + COMPONENT(GENERICFACTORY, nsGenericFactory::Create), + COMPONENT(EVENTQUEUESERVICE, nsEventQueueServiceImplConstructor), + COMPONENT(EVENTQUEUE, nsEventQueueImpl::Create), + COMPONENT(THREAD, nsThread::Create), + +#define NS_XPCOMPROXY_CID NS_PROXYEVENT_MANAGER_CID + COMPONENT(XPCOMPROXY, nsProxyObjectManager::Create), + + COMPONENT(TIMER, nsTimerImplConstructor), + COMPONENT(TIMERMANAGER, nsTimerManagerConstructor), + +#define COMPONENT_SUPPORTS(TYPE, Type) \ + COMPONENT(SUPPORTS_##TYPE, nsSupports##Type##ImplConstructor) + + COMPONENT_SUPPORTS(ID, ID), + COMPONENT_SUPPORTS(STRING, String), + COMPONENT_SUPPORTS(CSTRING, CString), + COMPONENT_SUPPORTS(PRBOOL, PRBool), + COMPONENT_SUPPORTS(PRUINT8, PRUint8), + COMPONENT_SUPPORTS(PRUINT16, PRUint16), + COMPONENT_SUPPORTS(PRUINT32, PRUint32), + COMPONENT_SUPPORTS(PRUINT64, PRUint64), + COMPONENT_SUPPORTS(PRTIME, PRTime), + COMPONENT_SUPPORTS(CHAR, Char), + COMPONENT_SUPPORTS(PRINT16, PRInt16), + COMPONENT_SUPPORTS(PRINT32, PRInt32), + COMPONENT_SUPPORTS(PRINT64, PRInt64), + COMPONENT_SUPPORTS(FLOAT, Float), + COMPONENT_SUPPORTS(DOUBLE, Double), + COMPONENT_SUPPORTS(VOID, Void), + COMPONENT_SUPPORTS(INTERFACE_POINTER, InterfacePointer), + +#undef COMPONENT_SUPPORTS +#define NS_LOCAL_FILE_CLASSNAME "Local File Specification" + COMPONENT(LOCAL_FILE, nsLocalFile::nsLocalFileConstructor), +#define NS_DIRECTORY_SERVICE_CLASSNAME "nsIFile Directory Service" + COMPONENT(DIRECTORY_SERVICE, nsDirectoryService::Create), + COMPONENT(PROCESS, nsProcessConstructor), + COMPONENT(ENVIRONMENT, nsEnvironment::Create), + + COMPONENT(STRINGINPUTSTREAM, nsStringInputStreamConstructor), + COMPONENT(MULTIPLEXINPUTSTREAM, nsMultiplexInputStreamConstructor), + + COMPONENT(FASTLOADSERVICE, nsFastLoadService::Create), + COMPONENT(VARIANT, nsVariantConstructor), + COMPONENT(INTERFACEINFOMANAGER_SERVICE, nsXPTIInterfaceInfoManagerGetSingleton), + + COMPONENT(RECYCLINGALLOCATOR, nsRecyclingAllocatorImplConstructor), + +#if 0 /// @todo later + { IPC_SERVICE_CLASSNAME, + IPC_SERVICE_CID, + IPC_SERVICE_CONTRACTID, + ipcServiceConstructor }, + /* + ipcServiceRegisterProc, + ipcServiceUnregisterProc }, + */ + // + // extensions go here: + // + { IPC_LOCKSERVICE_CLASSNAME, + IPC_LOCKSERVICE_CID, + IPC_LOCKSERVICE_CONTRACTID, + ipcLockServiceConstructor }, + { IPC_TRANSACTIONSERVICE_CLASSNAME, + IPC_TRANSACTIONSERVICE_CID, + IPC_TRANSACTIONSERVICE_CONTRACTID, + tmTransactionServiceConstructor }, + +#ifdef BUILD_DCONNECT + { IPC_DCONNECTSERVICE_CLASSNAME, + IPC_DCONNECTSERVICE_CID, + IPC_DCONNECTSERVICE_CONTRACTID, + ipcDConnectServiceConstructor, + ipcDConnectServiceRegisterProc, + ipcDConnectServiceUnregisterProc }, +#endif +#endif +}; + +#undef COMPONENT + +const int components_length = sizeof(components) / sizeof(components[0]); + +// gMemory will be freed during shutdown. +static nsIMemory* gMemory = nsnull; +nsresult NS_COM NS_GetMemoryManager(nsIMemory* *result) +{ + nsresult rv = NS_OK; + if (!gMemory) + { + rv = nsMemoryImpl::Create(nsnull, + NS_GET_IID(nsIMemory), + (void**)&gMemory); + } + NS_IF_ADDREF(*result = gMemory); + return rv; +} + +// gDebug will be freed during shutdown. +static nsIDebug* gDebug = nsnull; +nsresult NS_COM NS_GetDebug(nsIDebug** result) +{ + nsresult rv = NS_OK; + if (!gDebug) + { + rv = nsDebugImpl::Create(nsnull, + NS_GET_IID(nsIDebug), + (void**)&gDebug); + } + NS_IF_ADDREF(*result = gDebug); + return rv; +} + +#ifdef NS_BUILD_REFCNT_LOGGING +// gTraceRefcnt will be freed during shutdown. +static nsITraceRefcnt* gTraceRefcnt = nsnull; +#endif + +nsresult NS_COM NS_GetTraceRefcnt(nsITraceRefcnt** result) +{ +#ifdef NS_BUILD_REFCNT_LOGGING + nsresult rv = NS_OK; + if (!gTraceRefcnt) + { + rv = nsTraceRefcntImpl::Create(nsnull, + NS_GET_IID(nsITraceRefcnt), + (void**)&gTraceRefcnt); + } + NS_IF_ADDREF(*result = gTraceRefcnt); + return rv; +#else + return NS_ERROR_NOT_INITIALIZED; +#endif +} + +nsresult NS_COM NS_InitXPCOM(nsIServiceManager* *result, + nsIFile* binDirectory) +{ + return NS_InitXPCOM2(result, binDirectory, nsnull); +} + +nsresult NS_COM NS_InitXPCOM2(nsIServiceManager* *result, + nsIFile* binDirectory, + nsIDirectoryServiceProvider* appFileLocationProvider) +{ + nsresult rv = NS_OK; + + // We are not shutting down + gXPCOMShuttingDown = PR_FALSE; + +#ifdef NS_BUILD_REFCNT_LOGGING + nsTraceRefcntImpl::Startup(); +#endif + + // Establish the main thread here. + rv = nsIThread::SetMainThread(); + if (NS_FAILED(rv)) return rv; + + // Set up the timer globals/timer thread + rv = nsTimerImpl::Startup(); + NS_ENSURE_SUCCESS(rv, rv); + + // Startup the memory manager + rv = nsMemoryImpl::Startup(); + if (NS_FAILED(rv)) return rv; + + // If the locale hasn't already been setup by our embedder, + // get us out of the "C" locale and into the system + if (strcmp(setlocale(LC_ALL, NULL), "C") == 0) + setlocale(LC_ALL, ""); + +#if defined(XP_UNIX) || defined(XP_OS2) + NS_StartupNativeCharsetUtils(); +#endif + NS_StartupLocalFile(); + + StartupSpecialSystemDirectory(); + + // Start the directory service so that the component manager init can use it. + rv = nsDirectoryService::Create(nsnull, + NS_GET_IID(nsIProperties), + (void**)&gDirectoryService); + if (NS_FAILED(rv)) + return rv; + + nsCOMPtr<nsIDirectoryService> dirService = do_QueryInterface(gDirectoryService, &rv); + if (NS_FAILED(rv)) + return rv; + rv = dirService->Init(); + if (NS_FAILED(rv)) + return rv; + + // Create the Component/Service Manager + nsComponentManagerImpl *compMgr = NULL; + + if (nsComponentManagerImpl::gComponentManager == NULL) + { + compMgr = new nsComponentManagerImpl(); + if (compMgr == NULL) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(compMgr); + + nsCOMPtr<nsIFile> xpcomLib; + + PRBool value; + if (binDirectory) + { + rv = binDirectory->IsDirectory(&value); + + if (NS_SUCCEEDED(rv) && value) { + gDirectoryService->Set(NS_XPCOM_INIT_CURRENT_PROCESS_DIR, binDirectory); + binDirectory->Clone(getter_AddRefs(xpcomLib)); + } + } + else { + gDirectoryService->Get(NS_XPCOM_CURRENT_PROCESS_DIR, + NS_GET_IID(nsIFile), + getter_AddRefs(xpcomLib)); + } + + if (xpcomLib) { + xpcomLib->AppendNative(nsDependentCString(XPCOM_DLL)); + gDirectoryService->Set(NS_XPCOM_LIBRARY_FILE, xpcomLib); + } + + if (appFileLocationProvider) { + rv = dirService->RegisterProvider(appFileLocationProvider); + if (NS_FAILED(rv)) return rv; + } + + rv = compMgr->Init(); + if (NS_FAILED(rv)) + { + NS_RELEASE(compMgr); + return rv; + } + + nsComponentManagerImpl::gComponentManager = compMgr; + + if (result) { + nsIServiceManager *serviceManager = + NS_STATIC_CAST(nsIServiceManager*, compMgr); + + NS_ADDREF(*result = serviceManager); + } + } + + nsCOMPtr<nsIMemory> memory; + NS_GetMemoryManager(getter_AddRefs(memory)); + // dougt - these calls will be moved into a new interface when nsIComponentManager is frozen. + rv = compMgr->RegisterService(kMemoryCID, memory); + if (NS_FAILED(rv)) return rv; + + rv = compMgr->RegisterService(kComponentManagerCID, NS_STATIC_CAST(nsIComponentManager*, compMgr)); + if (NS_FAILED(rv)) return rv; + +#ifdef GC_LEAK_DETECTOR + rv = NS_InitLeakDetector(); + if (NS_FAILED(rv)) return rv; +#endif + + // 2. Register the global services with the component manager so that + // clients can create new objects. + + // Category Manager + { + nsCOMPtr<nsIFactory> categoryManagerFactory; + if ( NS_FAILED(rv = NS_CategoryManagerGetFactory(getter_AddRefs(categoryManagerFactory))) ) + return rv; + + NS_DEFINE_CID(kCategoryManagerCID, NS_CATEGORYMANAGER_CID); + + rv = compMgr->RegisterFactory(kCategoryManagerCID, + NS_CATEGORYMANAGER_CLASSNAME, + NS_CATEGORYMANAGER_CONTRACTID, + categoryManagerFactory, + PR_TRUE); + if ( NS_FAILED(rv) ) return rv; + } + + // what I want to do here is QI for a Component Registration Manager. Since this + // has not been invented yet, QI to the obsolete manager. Kids, don't do this at home. + nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface( + NS_STATIC_CAST(nsIComponentManager*,compMgr), &rv); + if (registrar) { + for (int i = 0; i < components_length; i++) + RegisterGenericFactory(registrar, &components[i]); + } + rv = nsComponentManagerImpl::gComponentManager->ReadPersistentRegistry(); +#ifdef DEBUG + if (NS_FAILED(rv)) { + printf("No Persistent Registry Found.\n"); + } +#endif + +#if 0 /// @todo later + rv = IPC_Init(); + if (NS_FAILED(rv)) + return rv; +#endif + + if ( NS_FAILED(rv) || CheckUpdateFile()) { + // if we find no persistent registry, we will try to autoregister + // the default components directory. + nsComponentManagerImpl::gComponentManager->AutoRegister(nsnull); + + // If the application is using a GRE, then, + // auto register components in the GRE directory as well. + // + // The application indicates that it's using an GRE by + // returning a valid nsIFile when queried (via appFileLocProvider) + // for the NS_GRE_DIR atom as shown below + // + + if ( appFileLocationProvider ) { + nsCOMPtr<nsIFile> greDir; + PRBool persistent = PR_TRUE; + + appFileLocationProvider->GetFile(NS_GRE_DIR, &persistent, getter_AddRefs(greDir)); + + if (greDir) { +#ifdef DEBUG_dougt + printf("start - Registering GRE components\n"); +#endif + rv = gDirectoryService->Get(NS_GRE_COMPONENT_DIR, + NS_GET_IID(nsIFile), + getter_AddRefs(greDir)); + if (NS_FAILED(rv)) { + NS_ERROR("Could not get GRE components directory!"); + return rv; + } + + // If the GRE contains any loaders, we want to know about it so that we can cause another + // autoregistration of the applications component directory. + int loaderCount = nsComponentManagerImpl::gComponentManager->GetLoaderCount(); + rv = nsComponentManagerImpl::gComponentManager->AutoRegister(greDir); + + if (loaderCount != nsComponentManagerImpl::gComponentManager->GetLoaderCount()) + nsComponentManagerImpl::gComponentManager->AutoRegisterNonNativeComponents(nsnull); + +#ifdef DEBUG_dougt + printf("end - Registering GRE components\n"); +#endif + if (NS_FAILED(rv)) { + NS_ERROR("Could not AutoRegister GRE components"); + return rv; + } + } + } + + // + // If additional component directories have been specified, then + // register them as well. + // + + nsCOMPtr<nsISimpleEnumerator> dirList; + gDirectoryService->Get(NS_XPCOM_COMPONENT_DIR_LIST, + NS_GET_IID(nsISimpleEnumerator), + getter_AddRefs(dirList)); + if (dirList) { + PRBool hasMore; + while (NS_SUCCEEDED(dirList->HasMoreElements(&hasMore)) && hasMore) { + nsCOMPtr<nsISupports> elem; + dirList->GetNext(getter_AddRefs(elem)); + if (elem) { + nsCOMPtr<nsIFile> dir = do_QueryInterface(elem); + if (dir) + nsComponentManagerImpl::gComponentManager->AutoRegister(dir); + + // XXX should we worry about new component loaders being + // XXX defined by this process? + } + } + } + + + // Make sure the compreg file's mod time is current. + nsCOMPtr<nsIFile> compregFile; + rv = gDirectoryService->Get(NS_XPCOM_COMPONENT_REGISTRY_FILE, + NS_GET_IID(nsIFile), + getter_AddRefs(compregFile)); + compregFile->SetLastModifiedTime(PR_Now() / 1000); + } + + // Pay the cost at startup time of starting this singleton. + nsIInterfaceInfoManager* iim = XPTI_GetInterfaceInfoManager(); + NS_IF_RELEASE(iim); +#ifdef VBOX + // Must initialize the EventQueueService singleton before anyone is + // using it. The notification below creates a thread which races creating + // the EventQueueService creation otherwise, no matter what. + nsCOMPtr<nsIEventQueue> eventQ; + rv = NS_GetMainEventQ(getter_AddRefs(eventQ)); + if (NS_FAILED(rv)) { + NS_ERROR("Could not create event queue for main thread"); + /* this is just a build-time hack, to reference NS_ProxyRelease */ + if (rv == 666) + NS_ProxyRelease(nsnull, nsnull); + return rv; + } +#endif /* VBOX */ + + // Notify observers of xpcom autoregistration start + NS_CreateServicesFromCategory(NS_XPCOM_STARTUP_OBSERVER_ID, + nsnull, + NS_XPCOM_STARTUP_OBSERVER_ID); + + return NS_OK; +} + + +static nsVoidArray* gExitRoutines; + +static void CallExitRoutines() +{ + if (!gExitRoutines) + return; + + PRInt32 count = gExitRoutines->Count(); + for (PRInt32 i = 0; i < count; i++) { + XPCOMExitRoutine func = (XPCOMExitRoutine) gExitRoutines->ElementAt(i); + func(); + } + gExitRoutines->Clear(); + delete gExitRoutines; + gExitRoutines = nsnull; +} + +nsresult NS_COM +NS_RegisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine, PRUint32 priority) +{ + // priority are not used right now. It will need to be implemented as more + // classes are moved into the glue library --dougt + if (!gExitRoutines) { + gExitRoutines = new nsVoidArray(); + if (!gExitRoutines) { + NS_WARNING("Failed to allocate gExitRoutines"); + return NS_ERROR_FAILURE; + } + } + + PRBool okay = gExitRoutines->AppendElement((void*)exitRoutine); + return okay ? NS_OK : NS_ERROR_FAILURE; +} + +nsresult NS_COM +NS_UnregisterXPCOMExitRoutine(XPCOMExitRoutine exitRoutine) +{ + if (!gExitRoutines) + return NS_ERROR_FAILURE; + + PRBool okay = gExitRoutines->RemoveElement((void*)exitRoutine); + return okay ? NS_OK : NS_ERROR_FAILURE; +} + + +// +// NS_ShutdownXPCOM() +// +// The shutdown sequence for xpcom would be +// +// - Release the Global Service Manager +// - Release all service instances held by the global service manager +// - Release the Global Service Manager itself +// - Release the Component Manager +// - Release all factories cached by the Component Manager +// - Unload Libraries +// - Release Contractid Cache held by Component Manager +// - Release dll abstraction held by Component Manager +// - Release the Registry held by Component Manager +// - Finally, release the component manager itself +// +nsresult NS_COM NS_ShutdownXPCOM(nsIServiceManager* servMgr) +{ + + // Notify observers of xpcom shutting down + nsresult rv = NS_OK; + { + // Block it so that the COMPtr will get deleted before we hit + // servicemanager shutdown + nsCOMPtr<nsIObserverService> observerService = + do_GetService("@mozilla.org/observer-service;1", &rv); + if (NS_SUCCEEDED(rv)) + { + nsCOMPtr<nsIServiceManager> mgr; + rv = NS_GetServiceManager(getter_AddRefs(mgr)); + if (NS_SUCCEEDED(rv)) + { + (void) observerService->NotifyObservers(mgr, + NS_XPCOM_SHUTDOWN_OBSERVER_ID, + nsnull); + } + } + } + + // grab the event queue so that we can process events one last time before exiting + nsCOMPtr <nsIEventQueue> currentQ; + { + nsCOMPtr<nsIEventQueueService> eventQService = + do_GetService(kEventQueueServiceCID, &rv); + + if (eventQService) { + eventQService->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(currentQ)); + } + } + // XPCOM is officially in shutdown mode NOW + // Set this only after the observers have been notified as this + // will cause servicemanager to become inaccessible. + gXPCOMShuttingDown = PR_TRUE; + +#ifdef DEBUG_dougt + fprintf(stderr, "* * * * XPCOM shutdown. Access will be denied * * * * \n"); +#endif + +#if 0 /// @todo later + IPC_Shutdown(); +#endif + + // We may have AddRef'd for the caller of NS_InitXPCOM, so release it + // here again: + NS_IF_RELEASE(servMgr); + + // Shutdown global servicemanager + if (nsComponentManagerImpl::gComponentManager) { + nsComponentManagerImpl::gComponentManager->FreeServices(); + } + nsServiceManager::ShutdownGlobalServiceManager(nsnull); + + if (currentQ) { + currentQ->ProcessPendingEvents(); + currentQ = 0; + } + + nsProxyObjectManager::Shutdown(); + + // Release the directory service + NS_IF_RELEASE(gDirectoryService); + + // Shutdown nsLocalFile string conversion + NS_ShutdownLocalFile(); +#ifdef XP_UNIX + NS_ShutdownNativeCharsetUtils(); +#endif + + // Shutdown the timer thread and all timers that might still be alive before + // shutting down the component manager + nsTimerImpl::Shutdown(); + + CallExitRoutines(); + + // Shutdown xpcom. This will release all loaders and cause others holding + // a refcount to the component manager to release it. + if (nsComponentManagerImpl::gComponentManager) { + rv = (nsComponentManagerImpl::gComponentManager)->Shutdown(); + NS_ASSERTION(NS_SUCCEEDED(rv), "Component Manager shutdown failed."); + } else + NS_WARNING("Component Manager was never created ..."); + + // Release our own singletons + // Do this _after_ shutting down the component manager, because the + // JS component loader will use XPConnect to call nsIModule::canUnload, + // and that will spin up the InterfaceInfoManager again -- bad mojo + XPTI_FreeInterfaceInfoManager(); + + // Finally, release the component manager last because it unloads the + // libraries: + if (nsComponentManagerImpl::gComponentManager) { + nsrefcnt cnt; + NS_RELEASE2(nsComponentManagerImpl::gComponentManager, cnt); + NS_WARN_IF_FALSE(cnt == 0, "Component Manager being held past XPCOM shutdown."); + } + nsComponentManagerImpl::gComponentManager = nsnull; + +#ifdef DEBUG + _FreeAutoLockStatics(); +#endif + + ShutdownSpecialSystemDirectory(); + + EmptyEnumeratorImpl::Shutdown(); + nsMemoryImpl::Shutdown(); + NS_IF_RELEASE(gMemory); + + nsThread::Shutdown(); + NS_PurgeAtomTable(); + + NS_IF_RELEASE(gDebug); + +#ifdef NS_BUILD_REFCNT_LOGGING + nsTraceRefcntImpl::DumpStatistics(); + nsTraceRefcntImpl::ResetStatistics(); + nsTraceRefcntImpl::Shutdown(); +#endif + +#ifdef GC_LEAK_DETECTOR + // Shutdown the Leak detector. + NS_ShutdownLeakDetector(); +#endif + + return NS_OK; +} + +#define GET_FUNC(_tag, _decl, _name) \ + functions->_tag = (_decl) PR_FindSymbol(xpcomLib, _name); \ + if (!functions->_tag) goto end + +nsresult NS_COM PR_CALLBACK +NS_GetFrozenFunctions(XPCOMFunctions *functions, const char* libraryPath) +{ + if (!functions) + return NS_ERROR_OUT_OF_MEMORY; + + if (functions->version != XPCOM_GLUE_VERSION) + return NS_ERROR_FAILURE; + + PRLibrary *xpcomLib = PR_LoadLibrary(libraryPath); + if (!xpcomLib) + return NS_ERROR_FAILURE; + + nsresult rv = NS_ERROR_FAILURE; + +#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP + GET_FUNC(init, InitFunc, "VBoxNsxpNS_InitXPCOM2"); + GET_FUNC(shutdown, ShutdownFunc, "VBoxNsxpNS_ShutdownXPCOM"); + GET_FUNC(getServiceManager, GetServiceManagerFunc, "VBoxNsxpNS_GetServiceManager"); + GET_FUNC(getComponentManager, GetComponentManagerFunc, "VBoxNsxpNS_GetComponentManager"); + GET_FUNC(getComponentRegistrar, GetComponentRegistrarFunc, "VBoxNsxpNS_GetComponentRegistrar"); + GET_FUNC(getMemoryManager, GetMemoryManagerFunc, "VBoxNsxpNS_GetMemoryManager"); + GET_FUNC(newLocalFile, NewLocalFileFunc, "VBoxNsxpNS_NewLocalFile"); + GET_FUNC(newNativeLocalFile, NewNativeLocalFileFunc, "VBoxNsxpNS_NewNativeLocalFile"); + GET_FUNC(registerExitRoutine, RegisterXPCOMExitRoutineFunc, "VBoxNsxpNS_RegisterXPCOMExitRoutine"); + GET_FUNC(unregisterExitRoutine, UnregisterXPCOMExitRoutineFunc, "VBoxNsxpNS_UnregisterXPCOMExitRoutine"); +#else /* !VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + GET_FUNC(init, InitFunc, "NS_InitXPCOM2"); + GET_FUNC(shutdown, ShutdownFunc, "NS_ShutdownXPCOM"); + GET_FUNC(getServiceManager, GetServiceManagerFunc, "NS_GetServiceManager"); + GET_FUNC(getComponentManager, GetComponentManagerFunc, "NS_GetComponentManager"); + GET_FUNC(getComponentRegistrar, GetComponentRegistrarFunc, "NS_GetComponentRegistrar"); + GET_FUNC(getMemoryManager, GetMemoryManagerFunc, "NS_GetMemoryManager"); + GET_FUNC(newLocalFile, NewLocalFileFunc, "NS_NewLocalFile"); + GET_FUNC(newNativeLocalFile, NewNativeLocalFileFunc, "NS_NewNativeLocalFile"); + GET_FUNC(registerExitRoutine, RegisterXPCOMExitRoutineFunc, "NS_RegisterXPCOMExitRoutine"); + GET_FUNC(unregisterExitRoutine, UnregisterXPCOMExitRoutineFunc, "NS_UnregisterXPCOMExitRoutine"); +#endif /* !VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + + // these functions were added post 1.4 (need to check size of |functions|) + if (functions->size > offsetof(XPCOMFunctions, getTraceRefcnt)) { +#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP + GET_FUNC(getDebug, GetDebugFunc, "VBoxNsxpNS_GetDebug"); + GET_FUNC(getTraceRefcnt, GetTraceRefcntFunc, "VBoxNsxpNS_GetTraceRefcnt"); +#else /* !VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + GET_FUNC(getDebug, GetDebugFunc, "NS_GetDebug"); + GET_FUNC(getTraceRefcnt, GetTraceRefcntFunc, "NS_GetTraceRefcnt"); +#endif /* !VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + } + + // these functions were added post 1.6 (need to check size of |functions|) + if (functions->size > offsetof(XPCOMFunctions, cstringCloneData)) { +#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP + GET_FUNC(stringContainerInit, StringContainerInitFunc, "VBoxNsxpNS_StringContainerInit"); + GET_FUNC(stringContainerFinish, StringContainerFinishFunc, "VBoxNsxpNS_StringContainerFinish"); + GET_FUNC(stringGetData, StringGetDataFunc, "VBoxNsxpNS_StringGetData"); + GET_FUNC(stringSetData, StringSetDataFunc, "VBoxNsxpNS_StringSetData"); + GET_FUNC(stringSetDataRange, StringSetDataRangeFunc, "VBoxNsxpNS_StringSetDataRange"); + GET_FUNC(stringCopy, StringCopyFunc, "VBoxNsxpNS_StringCopy"); + GET_FUNC(cstringContainerInit, CStringContainerInitFunc, "VBoxNsxpNS_CStringContainerInit"); + GET_FUNC(cstringContainerFinish, CStringContainerFinishFunc, "VBoxNsxpNS_CStringContainerFinish"); + GET_FUNC(cstringGetData, CStringGetDataFunc, "VBoxNsxpNS_CStringGetData"); + GET_FUNC(cstringSetData, CStringSetDataFunc, "VBoxNsxpNS_CStringSetData"); + GET_FUNC(cstringSetDataRange, CStringSetDataRangeFunc, "VBoxNsxpNS_CStringSetDataRange"); + GET_FUNC(cstringCopy, CStringCopyFunc, "VBoxNsxpNS_CStringCopy"); + GET_FUNC(cstringToUTF16, CStringToUTF16, "VBoxNsxpNS_CStringToUTF16"); + GET_FUNC(utf16ToCString, UTF16ToCString, "VBoxNsxpNS_UTF16ToCString"); + GET_FUNC(stringCloneData, StringCloneDataFunc, "VBoxNsxpNS_StringCloneData"); + GET_FUNC(cstringCloneData, CStringCloneDataFunc, "VBoxNsxpNS_CStringCloneData"); +#else /* !VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + GET_FUNC(stringContainerInit, StringContainerInitFunc, "NS_StringContainerInit"); + GET_FUNC(stringContainerFinish, StringContainerFinishFunc, "NS_StringContainerFinish"); + GET_FUNC(stringGetData, StringGetDataFunc, "NS_StringGetData"); + GET_FUNC(stringSetData, StringSetDataFunc, "NS_StringSetData"); + GET_FUNC(stringSetDataRange, StringSetDataRangeFunc, "NS_StringSetDataRange"); + GET_FUNC(stringCopy, StringCopyFunc, "NS_StringCopy"); + GET_FUNC(cstringContainerInit, CStringContainerInitFunc, "NS_CStringContainerInit"); + GET_FUNC(cstringContainerFinish, CStringContainerFinishFunc, "NS_CStringContainerFinish"); + GET_FUNC(cstringGetData, CStringGetDataFunc, "NS_CStringGetData"); + GET_FUNC(cstringSetData, CStringSetDataFunc, "NS_CStringSetData"); + GET_FUNC(cstringSetDataRange, CStringSetDataRangeFunc, "NS_CStringSetDataRange"); + GET_FUNC(cstringCopy, CStringCopyFunc, "NS_CStringCopy"); + GET_FUNC(cstringToUTF16, CStringToUTF16, "NS_CStringToUTF16"); + GET_FUNC(utf16ToCString, UTF16ToCString, "NS_UTF16ToCString"); + GET_FUNC(stringCloneData, StringCloneDataFunc, "NS_StringCloneData"); + GET_FUNC(cstringCloneData, CStringCloneDataFunc, "NS_CStringCloneData"); +#endif /* !VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */ + } + + rv = NS_OK; +end: + PR_UnloadLibrary(xpcomLib); // the library is refcnt'ed above by the caller. + return rv; +} diff --git a/src/libs/xpcom18a4/xpcom/build/win32.order b/src/libs/xpcom18a4/xpcom/build/win32.order new file mode 100644 index 00000000..ce6856ba --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/win32.order @@ -0,0 +1,1514 @@ +??1nsCOMPtr_base@@QAE@XZ ; 33017395 +?ElementAt@nsVoidArray@@QBEPAXH@Z ; 14120786 +?AddRef@nsEventQueueServiceImpl@@UAGKXZ ; 13612685 +?Release@AtomImpl@@UAGKXZ ; 13067618 +?Initialize@nsStr@@SAXAAU1@W4eCharSize@@@Z ; 9860800 +?Reference@nsCWeakProxy@@QAEPAXXZ ; 9283082 +?Free@nsStr@@CAHAAU1@@Z ; 8492496 +?Destroy@nsStr@@SAXAAU1@@Z ; 8159980 +??1nsString@@UAE@XZ ; 7681847 +??0nsString@@QAE@XZ ; 7538998 +?GetWritableFragment@nsString@@MAEPAGAAU?$nsWritableFragment@G@@W4nsFragmentRequest@@I@Z ; 7387979 +?Initialize@nsStr@@SAXAAU1@PADIIW4eCharSize@@H@Z ; 7301440 +??1nsAutoString@@UAE@XZ ; 6828894 +??0nsAutoString@@QAE@XZ ; 6681318 +?normalize_forward@?$nsReadingIterator@G@@QAEXXZ ; 6469200 +?normalize_forward@?$nsWritingIterator@D@@QAEXXZ ; 4717355 +?StrTruncate@nsStr@@SAXAAU1@I@Z ; 4534497 +?assign_from_helper@nsCOMPtr_base@@QAEXABVnsCOMPtr_helper@@ABUnsID@@@Z ; 4516612 +??0nsHashKey@@IAE@XZ ; 4270805 +??1nsHashKey@@UAE@XZ ; 4268636 +??RnsQueryInterface@@UBEIABUnsID@@PAPAX@Z ; 4148520 +?SetLength@nsCString@@UAEXI@Z ; 4098410 +?Get@nsHashtable@@QAEPAXPAVnsHashKey@@@Z ; 3790063 +?GetFlatBufferHandle@nsLocalString@@UBEPBV?$nsBufferHandle@G@@XZ ; 3747888 +?BeginReading@nsACString@@QBEAAV?$nsReadingIterator@D@@AAV2@@Z ; 3649883 +?FindChar1@@YAHPBDIHGHH@Z ; 2533672 +?BeginWriting@nsACString@@QAEAAV?$nsWritingIterator@D@@AAV2@@Z ; 2226534 +?advance@?$nsWritingIterator@G@@QAEAAV1@H@Z ; 2049632 +?advance@?$nsReadingIterator@G@@QAEAAV1@H@Z ; 1995545 +?GetReadableFragment@nsAFlatCString@@MBEPBDAAU?$nsReadableFragment@D@@W4nsFragmentRequest@@I@Z ; 1948988 +?Count@nsSupportsArray@@UAGIPAI@Z ; 1839978 +?readable_distance@?$nsCharSourceTraits@V?$nsReadingIterator@G@@@@SAIABV?$nsReadingIterator@G@@0@Z ; 1802375 +?GetReadableFragment@nsCString@@MBEPBDAAU?$nsReadableFragment@D@@W4nsFragmentRequest@@I@Z ; 1763345 +??0nsQueryInterface@@QAE@PAVnsISupports@@PAI@Z ; 1655422 +?copy_string@@YAAAV?$nsWritingIterator@G@@AAV?$nsReadingIterator@G@@ABV2@AAV1@@Z ; 1487171 +?GetWritableFragment@nsAFlatString@@MAEPAGAAU?$nsWritableFragment@G@@W4nsFragmentRequest@@I@Z ; 1391163 +?advance@?$nsWritingIterator@D@@QAEAAV1@H@Z ; 1335661 +?Equals@nsAString@@QBEHABV1@@Z ; 1318787 +?move@?$nsCharTraits@G@@SAPAGPAGPBGI@Z ; 1315826 +?assign_with_AddRef@nsCOMPtr_base@@QAEXPAVnsISupports@@@Z ; 1259090 +?write@?$nsWritingIterator@G@@QAEIPBGI@Z ; 1243674 +?Get@nsSupportsHashtable@@QAEPAVnsISupports@@PAVnsHashKey@@@Z ; 1199544 +?GetUnicode@nsString@@QBEPBGXZ ; 1141413 +?StrAppend@nsStr@@SAXAAU1@ABU1@IH@Z ; 1102413 +?FindChar@nsString@@QBEHGHHH@Z ; 1090463 +?FindChar@nsStr@@SAHABU1@GHHH@Z ; 1090463 +?FindChar2@@YAHPBDIHGHH@Z ; 1056090 +?ElementAt@nsSupportsArray@@UAGPAVnsISupports@@I@Z ; 1055798 +?InsertElementAt@nsVoidArray@@QAEHPAXH@Z ; 926721 +?Compare2To2@@YAHPBD0IH@Z ; 920121 +?EnumerateForwards@nsSupportsArray@@UAGHP6AHPAVnsISupports@@PAX@Z1@Z ; 908730 +?strncasecmp@nsCRT@@SAHPBG0I@Z ; 896894 +?StrCompare@nsStr@@SAHABU1@0HH@Z ; 886450 +?Free@nsMemoryImpl@@UAGXPAX@Z ; 842646 +?Free@nsMemory@@SAXPAX@Z ; 832569 +?Distance@@YAIABV?$nsReadingIterator@G@@0@Z ; 801833 +?copy_string@@YAAAV?$CalculateLength@G@@AAV?$nsReadingIterator@G@@ABV2@AAV1@@Z ; 801833 +?Compare2To1@@YAHPBD0IH@Z ; 797802 +?Alloc@nsMemoryImpl@@UAGPAXI@Z ; 795063 +?Length@nsAFlatString@@UBEIXZ ; 789895 +?advance@?$nsReadingIterator@D@@QAEAAV1@H@Z ; 778072 +?copy_string@@YAAAV?$nsWritingIterator@D@@AAV?$nsReadingIterator@D@@ABV2@AAV1@@Z ; 738318 +?Alloc@nsMemory@@SAPAXI@Z ; 731916 +?write@?$nsWritingIterator@D@@QAEIPBDI@Z ; 724438 +?EqualsWithConversion@nsString@@QBEHABV1@HH@Z ; 680848 +?EqualsIgnoreCase@nsString@@QBEHABV1@@Z ; 680848 +?Length@nsAFlatCString@@UBEIXZ ; 674814 +?GetReadableFragment@nsSlidingSubstring@@MBEPBGAAU?$nsReadableFragment@G@@W4nsFragmentRequest@@I@Z ; 671287 +?do_AppendFromReadable@nsAString@@MAEXABV1@@Z ; 657779 +?Compare@@YAHABVnsAString@@0@Z ; 630913 +?do_AssignFromReadable@nsAString@@MAEXABV1@@Z ; 630139 +?CopyChars2To2@@YAXPADHPBDII@Z ; 615216 +?do_AppendFromReadable@nsACString@@MAEXABV1@@Z ; 584996 +?ObjectAt@nsDeque@@QBEPAXH@Z ; 568869 +?InsertElementAt@nsSupportsArray@@UAGHPAVnsISupports@@I@Z ; 548718 +?AssignFromReadable@nsACString@@IAEXABV1@@Z ; 534684 +??0nsLocalCString@@QAE@PBD@Z ; 525422 +?strlen@nsCRT@@SAIPBG@Z ; 517372 +?get@nsString@@UBEPBGXZ ; 500471 +?GrowCapacity@nsStr@@SAHAAU1@I@Z ; 493115 +?Realloc@nsStr@@CAHAAU1@I@Z ; 493115 +?Alloc@nsStr@@CAHAAU1@I@Z ; 493115 +?EnsureCapacity@nsStr@@SAHAAU1@I@Z ; 493115 +??0nsVoidArray@@QAE@XZ ; 490358 +?strncmp@nsCRT@@SAHPBGPBDI@Z ; 489334 +??1nsVoidArray@@UAE@XZ ; 481308 +??1nsCString@@UAE@XZ ; 478019 +?RemoveElementAt@nsVoidArray@@QAEHH@Z ; 473592 +?AppendElement@nsSupportsArray@@UAGIPAVnsISupports@@@Z ; 464186 +?AppendWithConversion@nsCString@@QAEXG@Z ; 452063 +??0nsCString@@QAE@XZ ; 449721 +?do_AppendFromElementPtr@nsACString@@MAEXPBD@Z ; 427640 +?SetArraySize@nsVoidArray@@IAEXH@Z ; 425906 +?get@nsPromiseFlatCString@@UBEPBDXZ ; 413903 +?Alloc@nsFixedSizeAllocator@@QAEPAXI@Z ; 411293 +??0nsPromiseFlatString@@IAE@ABVnsAString@@@Z ; 410015 +?Free@nsFixedSizeAllocator@@SAXPAXI@Z ; 401028 +?strcmp@nsCRT@@SAHPBG0@Z ; 400500 +??1nsPromiseFlatString@@UAE@XZ ; 398346 +??1nsCAutoString@@UAE@XZ ; 391273 +?GetFlatBufferHandle@nsCString@@MBEPBV?$nsBufferHandle@D@@XZ ; 385981 +?Push@nsDeque@@QAEAAV1@PAX@Z ; 367628 +?Equals@nsIDKey@@UBEHPBVnsHashKey@@@Z ; 358933 +?Clear@nsSupportsArray@@UAGIXZ ; 352217 +?AppendFromReadable@nsAString@@IAEXABV1@@Z ; 352181 +?strncasecmp@nsCRT@@SAHPBGPBDI@Z ; 330906 +?IsAsciiAlpha@nsCRT@@SAHG@Z ; 327047 +??0nsCAutoString@@QAE@XZ ; 311314 +?Clear@nsVoidArray@@QAEXXZ ; 287750 +?Compare1To1@@YAHPBD0IH@Z ; 276525 +?Length@nsSlidingSubstring@@UBEIXZ ; 264724 +?PopFront@nsDeque@@QAEPAXXZ ; 260861 +?AcquireNonOwningReference@Buffer@nsSharedBufferList@@QBEXXZ ; 256259 +?Distance@Position@nsSharedBufferList@@SAHABU12@0@Z ; 254042 +?DiscardUnreferencedPrefix@nsSlidingSharedBufferList@@QAEXPAVBuffer@nsSharedBufferList@@@Z ; 254040 +?ReleaseNonOwningReference@Buffer@nsSharedBufferList@@QBEXXZ ; 254040 +??1nsCStringKey@@UAE@XZ ; 253255 +?HashCode@nsCRT@@SAIPBDPAI@Z ; 251093 +?HashCode@nsCStringKey@@UBEIXZ ; 250679 +?NS_GetGlobalComponentManager@@YAIPAPAVnsIComponentManager@@@Z ; 250625 +??1nsAFlatString@@UAE@XZ ; 249908 +??0nsAFlatString@@QAE@XZ ; 243174 +?Equals@nsCStringKey@@UBEHPBVnsHashKey@@@Z ; 238528 +?IsAsciiSpace@nsCRT@@SAHG@Z ; 238314 +?CopyChars1To2@@YAXPADHPBDII@Z ; 237716 +??0nsLocalString@@QAE@PBGI@Z ; 236845 +?NS_NewAtom@@YAPAVnsIAtom@@ABVnsAString@@@Z ; 235384 +?Release@nsSupportsArray@@UAGKXZ ; 229149 +?GetParameterCount@nsProxyObjectCallInfo@@QBEIXZ ; 228843 +??0nsAutoVoidArray@@QAE@XZ ; 223605 +?do_AppendFromElementPtrLength@nsAString@@MAEXPBGI@Z ; 221664 +?AppendWithConversion@nsString@@QAEXPBDH@Z ; 216212 +?ChangeCase@nsStr@@SAXAAU1@H@Z ; 211594 +?length@?$nsCharTraits@G@@SAIPBG@Z ; 206064 +??0nsLocalString@@QAE@PBG@Z ; 205367 +?SetArrayOwner@nsVoidArray@@IAEXH@Z ; 202301 +?GetFactoryEntry@nsComponentManagerImpl@@IAEPAVnsFactoryEntry@@ABUnsID@@H@Z ; 198436 +?FindFactory@nsComponentManagerImpl@@UAGIABUnsID@@PAPAVnsIFactory@@@Z ; 198385 +?GetFactory@nsFactoryEntry@@QAEIPAPAVnsIFactory@@PAVnsComponentManagerImpl@@@Z ; 198384 +?CreateInstance@nsComponentManagerImpl@@UAGIABUnsID@@PAVnsISupports@@0PAPAX@Z ; 198351 +?ToLowerCase@nsString@@QAEXXZ ; 198180 +?Remove@nsHashtable@@QAEPAXPAVnsHashKey@@@Z ; 191685 +?ToString@AtomImpl@@UAGIAAVnsAString@@@Z ; 189337 +?First@nsAString@@QBEGXZ ; 189245 +?release_ownership_of_buffer_list@nsSlidingSubstring@@AAEXXZ ; 188763 +?IndexOf@nsVoidArray@@QBEHPAX@Z ; 175677 +?StartAssignmentByValue@nsXPIDLString@@AAEPAPAGXZ ; 173850 +?SetCapacity@nsString@@UAEXI@Z ; 170493 +?CopyChars2To1@@YAXPADHPBDII@Z ; 168065 +?Put@nsHashtable@@QAEPAXPAVnsHashKey@@PAX@Z ; 160536 +?DiscardPrefix@nsSlidingString@@QAEXABV?$nsReadingIterator@G@@@Z ; 159450 +?StrAssign@nsStr@@SAXAAU1@ABU1@IH@Z ; 154324 +?Trim@nsStr@@SAXAAU1@PBDHH@Z ; 154152 +?SetCapacity@nsCString@@UAEXI@Z ; 151535 +?GetGlobalServiceManager@nsServiceManager@@SAIPAPAVnsIServiceManager@@@Z ; 148522 +?GetService@nsServiceManagerImpl@@UAGIABUnsID@@0PAPAVnsISupports@@PAVnsIShutdownListener@@@Z ; 146024 +?AddListener@nsServiceEntry@@QAEIPAVnsIShutdownListener@@@Z ; 146022 +?GetUnicode@AtomImpl@@UAGIPAPBG@Z ; 143965 +?Pop@nsDeque@@QAEPAXXZ ; 143309 +??RnsQueryReferent@@UBEIABUnsID@@PAPAX@Z ; 142474 +?normalize_backward@?$nsReadingIterator@G@@QAEXXZ ; 142302 +?QueryReferent@nsWeakReference@@UAGIABUnsID@@PAPAX@Z ; 142237 +?AddRef@nsStorageStream@@UAGKXZ ; 141846 +?Assign@nsACString@@QAEXPBD@Z ; 141606 +?FindCharInSet@nsStr@@SAHABU1@0HH@Z ; 138161 +?FindCharInSet@nsCString@@QBEHPBDH@Z ; 138161 +?CreateInstance@nsComponentManager@@SAIABUnsID@@PAVnsISupports@@0PAPAX@Z ; 137059 +??0nsCStringKey@@QAE@PBDHW4Ownership@0@@Z ; 136293 +??1nsXPIDLCString@@UAE@XZ ; 134911 +??0nsString@@QAE@ABV0@@Z ; 134194 +?do_AssignFromReadable@nsACString@@MAEXABV1@@Z ; 128929 +?ConvertCase1@@YAHPADIH@Z ; 128876 +?AssignWithConversion@nsCString@@QAEXPBGH@Z ; 122216 +?do_AppendFromElement@nsACString@@MAEXD@Z ; 120364 +?Write@FileImpl@@UAGIPBDIPAI@Z ; 120089 +?AssignWithConversion@nsCString@@QAEXABVnsString@@@Z ; 119962 +?AddRef@nsSupportsStringImpl@@UAGKXZ ; 118646 +??0nsCStringKey@@QAE@ABVnsCString@@@Z ; 117124 +?GetResolveState@xptiInterfaceInfo@@QBEEXZ ; 117066 +?AppendUnicodeTo@@YAXABV?$nsReadingIterator@G@@0AAVnsAString@@@Z ; 115792 +?AssignWithConversion@nsString@@QAEXPBD@Z ; 115695 +?Last@nsAString@@QBEGXZ ; 115018 +?ContractIDToClassID@nsComponentManagerImpl@@UAGIPBDPAUnsID@@@Z ; 112973 +?ToNewCString@nsCString@@QBEPADXZ ; 110413 +?LookupLowercasedKeyword@@YAHABVnsCString@@PAVnsHashtable@@@Z ; 110405 +?IsAsciiDigit@nsCRT@@SAHG@Z ; 107530 +?Remove@nsSupportsHashtable@@QAEHPAVnsHashKey@@PAPAVnsISupports@@@Z ; 106325 +??0nsAutoString@@QAE@ABVnsString@@@Z ; 103799 +?CompareWithConversion@nsString@@QBEHPBDHH@Z ; 102438 +?EqualsWithConversion@nsString@@QBEHPBDHH@Z ; 101441 +?Lookup@nsStaticCaseInsensitiveNameTable@@QAEHABVnsString@@@Z ; 101178 +?Trim@nsString@@QAEXPBDHHH@Z ; 100923 +?Release@nsWeakReference@@UAGKXZ ; 100809 +?GetReadableFragment@nsPromiseSubstring@@MBEPBGAAU?$nsReadableFragment@G@@W4nsFragmentRequest@@I@Z ; 98711 +?GetService@nsServiceManager@@SAIABUnsID@@0PAPAVnsISupports@@PAVnsIShutdownListener@@@Z ; 97630 +?write@nsOutputStream@@QAEHPBXH@Z ; 96747 +?Init@nsXPTCVariant@@QAEXABUnsXPTCMiniVariant@@ABVnsXPTType@@E@Z ; 95698 +?acquire_ownership_of_buffer_list@nsSlidingString@@ABEXXZ ; 94592 +?ReleaseReference@nsSlidingSharedBufferList@@QAEXXZ ; 94590 +??1nsSlidingSubstring@@UAE@XZ ; 94580 +??0nsSlidingSubstring@@QAE@XZ ; 94173 +?RemoveElement@nsVoidArray@@QAEHPAX@Z ; 91746 +??RnsGetServiceByCID@@UBEIABUnsID@@PAPAX@Z ; 91521 +??0nsGetServiceByCID@@QAE@ABUnsID@@PAVnsISupports@@PAI@Z ; 91521 +?Release@nsEventQueueImpl@@UAGKXZ ; 87880 +?EqualsIgnoreCase@nsString@@QBEHPBDH@Z ; 86030 +?Init@NS_ConvertUTF8toUCS2@@IAEXPBDI@Z ; 85607 +?Rebind@nsSlidingSubstring@@QAEXABVnsSlidingString@@ABV?$nsReadingIterator@G@@1@Z ; 83943 +?do_AppendFromElementPtr@nsAString@@MAEXPBG@Z ; 83867 +??0nsSupportsArray@@QAE@XZ ; 83106 +?ConvertCase2@@YAHPADIH@Z ; 82718 +?DeleteArray@nsSupportsArray@@IAEXXZ ; 82548 +??1nsSupportsArray@@UAE@XZ ; 82548 +?QueryInterface@nsSupportsArray@@UAGIABUnsID@@PAPAX@Z ; 81918 +?Create@nsSupportsArray@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 81725 +?NS_NewISupportsArray@@YAIPAPAVnsISupportsArray@@@Z ; 81666 +?CopyChars1To1@@YAXPADHPBDII@Z ; 81524 +??_EnsSupportsArray@@UAEPAXI@Z ; 81168 +?GetMethodInfo@xptiInterfaceInfo@@UAGIGPAPBVnsXPTMethodInfo@@@Z ; 78229 +?Release@xptiInterfaceInfo@@UAGKXZ ; 76117 +?do_AssignFromElementPtr@nsAString@@MAEXPBG@Z ; 73811 +?copy_string@@YAAAPAGAAV?$nsReadingIterator@G@@ABV1@AAPAG@Z ; 71847 +?GetReadableFragment@nsPromiseCSubstring@@MBEPBDAAU?$nsReadableFragment@D@@W4nsFragmentRequest@@I@Z ; 71331 +?GetBuffer@ByteBufferImpl@@UBGPADXZ ; 71201 +?Read@ConverterInputStream@@UAGIPAGIIPAI@Z ; 70839 +?Read@nsPersistentProperties@@QAEHXZ ; 70367 +?do_AssignFromElementPtr@nsACString@@MAEXPBD@Z ; 62916 +?Length@nsPromiseCSubstring@@UBEIXZ ; 62793 +?CompareWithConversion@nsCString@@QBEHPBDHH@Z ; 62172 +??0NS_ConvertASCIItoUCS2@@QAE@PBD@Z ; 61750 +?CreateInstanceByContractID@nsComponentManagerImpl@@UAGIPBDPAVnsISupports@@ABUnsID@@PAPAX@Z ; 61075 +?CreateInstance@nsComponentManager@@SAIPBDPAVnsISupports@@ABUnsID@@PAPAX@Z ; 61075 +?Exit@nsAutoMonitor@@QAEXXZ ; 59293 +?Enter@nsAutoMonitor@@QAEXXZ ; 59293 +PL_GetEventOwner ; 55295 +?RefCountInInterfacePointers@nsProxyObjectCallInfo@@AAEXH@Z ; 55218 +?Clone@nsMemory@@SAPAXPBXI@Z ; 53069 +?Promises@nsAString@@UBEHABV1@@Z ; 52421 +?Promises@nsPromiseSubstring@@UBEHABVnsAString@@@Z ; 52287 +?ContractIDToClassID@nsComponentManager@@SAIPBDPAUnsID@@@Z ; 51898 +?GetStringValue@nsStaticCaseInsensitiveNameTable@@QAEABVnsCString@@H@Z ; 51863 +?CopyUnicodeTo@@YAXABV?$nsReadingIterator@G@@0AAVnsAString@@@Z ; 51424 +??RnsGetInterface@@UBEIABUnsID@@PAPAX@Z ; 51014 +?GetService@nsServiceManager@@SAIPBDABUnsID@@PAPAVnsISupports@@PAVnsIShutdownListener@@@Z ; 50614 +?GetService@nsServiceManagerImpl@@UAGIPBDABUnsID@@PAPAVnsISupports@@PAVnsIShutdownListener@@@Z ; 50608 +?GetElementAt@nsSupportsArray@@UAGIIPAPAVnsISupports@@@Z ; 50421 +??0nsCAutoString@@QAE@PBD@Z ; 50288 +?Release@nsGenericFactory@@UAGKXZ ; 48967 +?Release@nsLocalFile@@UAGKXZ ; 48924 +?CreateInstance@nsGenericFactory@@UAGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 47807 +?ToNewUnicode@@YAPAGABVnsAString@@@Z ; 47476 +?Equals@nsSupportsArray@@UAGHPBVnsISupportsArray@@@Z ; 47394 +?QueryInterface@nsWeakReference@@UAGIABUnsID@@PAPAX@Z ; 47232 +?ToInteger@nsString@@QBEHPAHI@Z ; 46397 +??0nsGetServiceByContractID@@QAE@PBDPAVnsISupports@@PAI@Z ; 45960 +??RnsGetServiceByContractID@@UBEIABUnsID@@PAPAX@Z ; 45960 +?Reset@nsHashtable@@QAEXP6AHPAVnsHashKey@@PAX1@Z1@Z ; 45160 +?Reset@nsHashtable@@QAEXXZ ; 44779 +?strdup@nsCRT@@SAPAGPBG@Z ; 44542 +?strndup@nsCRT@@SAPAGPBGI@Z ; 44542 +PL_InitEvent ; 42216 +PL_DestroyEvent ; 42216 +?Release@nsProxyObject@@UAGKXZ ; 42053 +?HashCode@nsCRT@@SAIPBGPAI@Z ; 41515 +?MakeDirty@nsLocalFile@@AAEXXZ ; 40921 +?CompressSet@nsStr@@SAXAAU1@PBDHH@Z ; 40756 +?FindSubstr@nsStr@@SAHABU1@0HHH@Z ; 40557 +XPTC_InvokeByIndex ; 40446 +?QueryInterface@nsEventQueueImpl@@UAGIABUnsID@@PAPAX@Z ; 40010 +?Peek@nsDeque@@QAEPAXXZ ; 39695 +?ToUpper@nsCRT@@SAGG@Z ; 39657 +?CopyStrings@nsProxyObjectCallInfo@@AAEXH@Z ; 39492 +PL_DHashTableOperate ; 39446 +??0nsDeque@@QAE@PAVnsDequeFunctor@@@Z ; 38500 +?Empty@nsDeque@@QAEAAV1@XZ ; 38489 +??1nsDeque@@QAE@XZ ; 38489 +?Erase@nsDeque@@QAEAAV1@XZ ; 38489 +?GetSegmentCount@nsSegmentedBuffer@@QAEIXZ ; 38168 +?Release@nsProxyEventObject@@UAGKXZ ; 37461 +?ReplaceElementAt@nsVoidArray@@QAEHPAXH@Z ; 37379 +??0nsAutoString@@QAE@PBG@Z ; 35740 +PL_GetEvent ; 34422 +PL_HandleEvent ; 34415 +PL_PostEvent ; 34415 +?PostEvent@nsEventQueueImpl@@UAG?AW4PRStatus@@PAUPLEvent@@@Z ; 34353 +?strncmp@nsCRT@@SAHPBG0I@Z ; 34311 +?Cut@nsAString@@UAEXII@Z ; 33933 +?Release@nsThread@@UAGKXZ ; 32675 +?GetInstance@nsProxyObjectManager@@SAPAV1@XZ ; 31747 +?EqualsWithConversion@nsCString@@QBEHPBGHH@Z ; 31327 +?CompareWithConversion@nsCString@@QBEHPBGHH@Z ; 31327 +?GetRealObject@nsProxyObject@@QBEPAVnsISupports@@XZ ; 30180 +PL_DHashStringKey ; 29743 +?QueryInterface@nsEventQueueServiceImpl@@UAGIABUnsID@@PAPAX@Z ; 29645 +?GetReadSegment@nsPipe@@QAEIIPAPBDPAI@Z ; 29618 +??1nsXPIDLString@@UAE@XZ ; 29310 +?Release@nsProxyEventClass@@UAGKXZ ; 29259 +??0nsPromiseSubstring@@QAE@ABVnsAString@@II@Z ; 29232 +?Compact@nsSupportsArray@@UAGIXZ ; 28635 +?Mid@nsAString@@QBEIAAV1@II@Z ; 28616 +?AssignFromPromise@nsAString@@IAEXABV1@@Z ; 28510 +?get@nsAFlatString@@UBEPBGXZ ; 28400 +?Equals@nsACString@@QBEHABV1@@Z ; 28339 +?convertMiniVariantToVariant@nsProxyObject@@AAEIPAVnsXPTMethodInfo@@PAUnsXPTCMiniVariant@@PAPAUnsXPTCVariant@@PAE@Z ; 27609 +??_EnsProxyObjectCallInfo@@UAEPAXI@Z ; 27609 +?Post@nsProxyObject@@QAEIIPAVnsXPTMethodInfo@@PAUnsXPTCMiniVariant@@PAVnsIInterfaceInfo@@@Z ; 27609 +??1nsProxyObjectCallInfo@@UAE@XZ ; 27609 +?CallMethod@nsProxyEventObject@@UAGIGPBVnsXPTMethodInfo@@PAUnsXPTCMiniVariant@@@Z ; 27609 +??0nsProxyObjectCallInfo@@QAE@PAVnsProxyObject@@PAVnsXPTMethodInfo@@IPAUnsXPTCVariant@@IPAUPLEvent@@@Z ; 27609 +?Append@NS_ConvertUCS2toUTF8@@IAEXPBGI@Z ; 27265 +?ReplaceChar@nsString@@QAEXPBDG@Z ; 26980 +?CompressSet@nsString@@QAEXPBDGHH@Z ; 26980 +?CompressChars2@@YAHPADIPBD@Z ; 26980 +?CompressWhitespace@nsString@@QAEXHH@Z ; 26980 +?assign_assuming_AddRef@nsCOMPtr_base@@IAEXPAVnsISupports@@@Z ; 26695 +?do_AssignFromElement@nsAString@@MAEXG@Z ; 25781 +??0nsCAutoString@@QAE@ABVCBufDescriptor@@@Z ; 25669 +??0CBufDescriptor@@QAE@PADHIH@Z ; 25623 +?RemoveElementAt@nsSupportsArray@@UAGHI@Z ; 25489 +PL_IsQueueOnCurrentThread ; 25382 +?GetInterfaceInfo@nsProxyEventObject@@UAGIPAPAVnsIInterfaceInfo@@@Z ; 25038 +?Equals@nsACString@@QBEHPBD@Z ; 24972 +?ReadSegments@nsPipeInputStream@nsPipe@@UAGIP6GIPAVnsIInputStream@@PAXPBDIIPAI@Z1I3@Z ; 24934 +?Cut@nsACString@@UAEXII@Z ; 24343 +?RemoveElement@nsSupportsArray@@UAGHPBVnsISupports@@I@Z ; 24174 +?RemoveElement@nsSupportsArray@@UAGIPAVnsISupports@@@Z ; 24174 +??0nsPromiseCSubstring@@QAE@ABVnsACString@@II@Z ; 23764 +?Mid@nsACString@@QBEIAAV1@II@Z ; 23764 +?AssignFromPromise@nsACString@@IAEXABV1@@Z ; 23764 +?ToNewUnicode@nsString@@QBEPAGXZ ; 23688 +?Last@nsACString@@QBEDXZ ; 22996 +?AssignWithConversion@nsCString@@QAEXABVnsAString@@@Z ; 22923 +?IsQueueOnCurrentThread@nsEventQueueImpl@@UAGIPAH@Z ; 22307 +?AppendWithConversion@nsString@@QAEXD@Z ; 22276 +?Compare1To2@@YAHPBD0IH@Z ; 22272 +?GetIID@xptiInterfaceInfo@@UAGIPAPAUnsID@@@Z ; 21683 +?Find@nsString@@QBEHPBDHHH@Z ; 21620 +?AppendFromReadable@nsACString@@IAEXABV1@@Z ; 21546 +??0nsLocalCString@@QAE@PBDI@Z ; 21266 +??0nsAString@@QAE@XZ ; 20650 +?HashCode@nsProxyEventKey@@UBEIXZ ; 20409 +?QueryInterface@nsLocalFile@@UAGIABUnsID@@PAPAX@Z ; 19832 +?QueryElementAt@nsSupportsArray@@UAGIIABUnsID@@PAPAX@Z ; 19439 +?HashCode@nsStringKey@@UBEIXZ ; 19128 +??1nsStringKey@@UAE@XZ ; 18271 +??RnsCreateInstanceByContractID@@UBEIABUnsID@@PAPAX@Z ; 17842 +?GetTypelibGuts@xptiWorkingSet@@QAEPAVxptiTypelibGuts@@ABVxptiTypelib@@@Z ; 17499 +?GetInfoAtNoAddRef@xptiTypelibGuts@@QAEPAVxptiInterfaceInfo@@G@Z ; 17499 +?GetInfoForParam@xptiInterfaceInfo@@UAGIGPBVnsXPTParamInfo@@PAPAVnsIInterfaceInfo@@@Z ; 17441 +?GetIIDForParam@xptiInterfaceInfo@@UAGIGPBVnsXPTParamInfo@@PAPAUnsID@@@Z ; 17381 +?Find@nsString@@QBEHABV1@HHH@Z ; 17158 +?NS_NewAtom@@YAPAVnsIAtom@@PBG@Z ; 17124 +?Delete@nsStr@@SAXAAU1@II@Z ; 17080 +?QueryInterface@nsProxyEventObject@@UAGIABUnsID@@PAPAX@Z ; 17047 +?StripChars@nsStr@@SAXAAU1@PBD@Z ; 16392 +?StripChars@nsCString@@QAEXPBD@Z ; 16392 +?Equals@nsVoidKey@@UBEHPBVnsHashKey@@@Z ; 15797 +?StripChar@nsString@@QAEXGH@Z ; 15611 +?do_AppendFromElementPtrLength@nsACString@@MAEXPBDI@Z ; 15433 +?NS_NewAtom@@YAPAVnsIAtom@@PBD@Z ; 14915 +?strcasecmp@nsCRT@@SAHPBG0@Z ; 14605 +?GetNewOrUsedClass@nsProxyEventClass@@SAPAV1@ABUnsID@@@Z ; 14587 +?do_GetService@@YA?BVnsGetServiceByCID@@ABUnsID@@PAI@Z ; 14568 +??0nsProxyEventObject@@QAE@PAVnsIEventQueue@@HPAVnsISupports@@PAVnsProxyEventClass@@PAV0@@Z ; 14476 +??0nsProxyObject@@QAE@PAVnsIEventQueue@@HPAVnsISupports@@@Z ; 14476 +??1nsProxyEventObject@@UAE@XZ ; 14444 +??_EnsProxyObject@@UAEPAXI@Z ; 14444 +??_EnsProxyEventObject@@UAEPAXI@Z ; 14444 +??1nsProxyObject@@UAE@XZ ; 14444 +?ReleaseData@nsSimpleCharString@@IAEXXZ ; 14127 +??1?$nsSharedBufferHandle@G@@QAE@XZ ; 13784 +?CompressChars1@@YAHPADIPBD@Z ; 13776 +?CompressSet@nsCString@@QAEXPBDGHH@Z ; 13776 +?ReplaceChar@nsCString@@QAEXPBDG@Z ; 13776 +??0NS_ConvertUCS2toUTF8@@QAE@ABVnsAString@@@Z ; 13501 +??0nsCString@@QAE@ABVnsACString@@@Z ; 13490 +?Compact@nsVoidArray@@QAEXXZ ; 13069 +?ResolveAndStat@nsLocalFile@@AAEIH@Z ; 13042 +?Trim@nsCString@@QAEXPBDHHH@Z ; 12473 +?ToCString@nsString@@QBEPADPADII@Z ; 12467 +?Copy@nsXPIDLCString@@SAPADPBD@Z ; 12345 +?StripChars1@@YAHPADIPBD@Z ; 12243 +PL_ProcessPendingEvents ; 11979 +?copy_string@@YAAAV?$LossyConvertEncoding@GD@@AAV?$nsReadingIterator@G@@ABV2@AAV1@@Z ; 11800 +?ToNewCString@@YAPADABVnsAString@@@Z ; 11800 +?ToNewUTF8String@@YAPADABVnsAString@@@Z ; 11776 +?Release@nsProxyObjectManager@@UAGKXZ ; 11736 +??1nsCommonString@@UAE@XZ ; 11669 +?UnlinkBuffer@nsSharedBufferList@@QAEPAVBuffer@1@PAV21@@Z ; 11567 +?FindItem@nsAVLTree@@QBEPAXPAX@Z ; 11472 +?ReallocData@nsSimpleCharString@@IAEXI@Z ; 11366 +?ShiftCharsLeft@@YAXPADIII@Z ; 11222 +?GetYoungest@nsEventQueueImpl@@UAGIPAPAVnsIEventQueue@@@Z ; 10964 +?SetFollowLinks@nsLocalFile@@UAGIH@Z ; 10936 +?GetYoungestEventQueue@nsEventQueueServiceImpl@@AAEIPAVnsIEventQueue@@PAPAV2@@Z ; 10928 +?GetThreadEventQueue@nsEventQueueServiceImpl@@UAGIPAUPRThread@@PAPAVnsIEventQueue@@@Z ; 10925 +??0nsSharedBufferList@@QAE@PAVBuffer@0@@Z ; 10649 +?init_range_from_buffer_list@nsSlidingSubstring@@AAEXXZ ; 10649 +?DestroyBuffers@nsSharedBufferList@@IAEXXZ ; 10647 +??_EnsSlidingSharedBufferList@@UAEPAXI@Z ; 10647 +??1nsSharedBufferList@@UAE@XZ ; 10647 +??RnsCreateInstanceByCID@@UBEIABUnsID@@PAPAX@Z ; 10636 +?Put@nsSupportsHashtable@@QAEHPAVnsHashKey@@PAVnsISupports@@PAPAV3@@Z ; 10605 +?ToLowerCase@nsString@@QBEXAAV1@@Z ; 10514 +?GetPath@nsLocalFile@@UAGIPAPAD@Z ; 10449 +??0nsStringKey@@QAE@PBGHW4Ownership@0@@Z ; 10430 +?AddRef@nsPipeInputStream@nsPipe@@UAGKXZ ; 10377 +?Release@nsPipeInputStream@nsPipe@@UAGKXZ ; 10375 +?Rebind@nsSlidingSubstring@@QAEXABVnsAString@@@Z ; 10240 +?PeekFront@nsDeque@@QAEPAXXZ ; 10192 +??2AtomImpl@@SAPAXIABVnsAString@@@Z ; 10144 +??0AtomImpl@@QAE@XZ ; 10144 +?ResolveEventQueue@nsEventQueueServiceImpl@@UAGIPAVnsIEventQueue@@PAPAV2@@Z ; 10065 +?ToNewUTF8String@nsString@@QBEPADXZ ; 10047 +PL_DHashTableEnumerate ; 9813 +?AddBucket@nsFixedSizeAllocator@@IAEII@Z ; 9776 +?AppendWithConversion@nsCString@@QAEXABVnsString@@H@Z ; 9758 +?Right@nsACString@@QBEIAAV1@I@Z ; 9591 +?Lookup@nsStaticCaseInsensitiveNameTable@@QAEHABVnsCString@@@Z ; 9227 +?Enumerate@nsHashtable@@QAEXP6AHPAVnsHashKey@@PAX1@Z1@Z ; 9133 +?GetParent@xptiInterfaceInfo@@UAGIPAPAVnsIInterfaceInfo@@@Z ; 9105 +_md_EventReceiverProc@16 ; 9061 +?InitWithPath@nsLocalFile@@UAGIPBD@Z ; 8986 +??0nsLocalFile@@QAE@XZ ; 8981 +??_EnsLocalFile@@UAEPAXI@Z ; 8977 +??1nsLocalFile@@UAE@XZ ; 8977 +NS_NewLocalFile ; 8952 +?GetWriteSegment@nsPipe@@QAEIPAPADPAI@Z ; 8809 +?GetProxyForObject@nsProxyObjectManager@@UAGIPAVnsIEventQueue@@ABUnsID@@PAVnsISupports@@HPAPAX@Z ; 8762 +?GetNewOrUsedProxy@nsProxyEventObject@@SAPAV1@PAVnsIEventQueue@@HPAVnsISupports@@ABUnsID@@@Z ; 8762 +?Equals@nsProxyEventKey@@UBEHPBVnsHashKey@@@Z ; 8745 +?AddRef@nsPipeOutputStream@nsPipe@@UAGKXZ ; 8650 +?Release@nsPipeOutputStream@nsPipe@@UAGKXZ ; 8649 +?Read@nsPipeInputStream@nsPipe@@UAGIPADIPAI@Z ; 8617 +??4nsXPIDLCString@@QAEAAV0@PBD@Z ; 8570 +??1nsSimpleCharString@@QAE@XZ ; 8555 +?Equals@nsStringKey@@UBEHPBVnsHashKey@@@Z ; 8497 +?AddRefData@nsSimpleCharString@@IAEXXZ ; 8367 +?Init@nsFixedSizeAllocator@@QAEIPBDPBIHHH@Z ; 7954 +??0nsStringKey@@QAE@ABVnsAString@@@Z ; 7944 +?Release@nsArrayEnumerator@@UAGKXZ ; 7923 +?PostCompleted@nsProxyObjectCallInfo@@QAEXXZ ; 7863 +?SetCompleted@nsProxyObjectCallInfo@@QAEXXZ ; 7863 +??0nsCString@@QAE@ABV0@@Z ; 7622 +?AppendNewSegment@nsSegmentedBuffer@@QAEPADXZ ; 7622 +??_GAtomImpl@@UAEPAXI@Z ; 7566 +??1AtomImpl@@UAE@XZ ; 7566 +??0nsCString@@QAE@PBD@Z ; 7541 +??0nsAutoString@@QAE@ABVCBufDescriptor@@@Z ; 7529 +??0NS_ConvertASCIItoUCS2@@QAE@PBDI@Z ; 7452 +??0nsString@@QAE@ABVnsAString@@@Z ; 7419 +??0CBufDescriptor@@QAE@PAGHIH@Z ; 7406 +??0nsCreateInstanceByContractID@@QAE@PBDPAVnsISupports@@PAI@Z ; 7402 +?EnumerateForwards@nsVoidArray@@QAEHP6AHPAX0@Z0@Z ; 7195 +?AppendInt@nsCString@@QAEXHH@Z ; 7047 +??RnsGetWeakReference@@UBEIABUnsID@@PAPAX@Z ; 7028 +?NS_GetWeakReference@@YAPAVnsIWeakReference@@PAVnsISupports@@PAI@Z ; 7022 +?Clone@nsLocalFile@@UAGIPAPAVnsIFile@@@Z ; 6960 +?AppendRelativePath@nsLocalFile@@UAGIPBD@Z ; 6927 +?Empty@nsSegmentedBuffer@@QAEXXZ ; 6878 +??_EnsIDKey@@UAEPAXI@Z ; 6876 +?Append@nsLocalFile@@UAGIPBD@Z ; 6818 +?RFindChar@nsStr@@SAHABU1@GHHH@Z ; 6753 +?RFindChar@nsString@@QBEHGHHH@Z ; 6753 +?GetWeakReference@nsSupportsWeakReference@@UAGIPAPAVnsIWeakReference@@@Z ; 6751 +?Release@nsMemoryImpl@@UAGKXZ ; 6468 +??1nsSupportsWeakReference@@UAE@XZ ; 6428 +?SetNonBlocking@nsPipeInputStream@nsPipe@@UAGIH@Z ; 6306 +PL_DHashTableRawRemove ; 6270 +?GetNext@nsArrayEnumerator@@UAGIPAPAVnsISupports@@@Z ; 6180 +?ReleaseService@nsServiceManagerImpl@@UAGIABUnsID@@PAVnsISupports@@PAVnsIShutdownListener@@@Z ; 6156 +?RFindSubstr@nsStr@@SAHABU1@0HHH@Z ; 6056 +?RFind@nsCString@@QBEHPBDHHH@Z ; 6052 +?HasMoreElements@nsDirEnumerator@@UAGIPAH@Z ; 5962 +?QueryInterface@nsProxyObjectManager@@UAGIABUnsID@@PAPAX@Z ; 5920 +?GetReadableFragment@nsSlidingString@@MBEPBGAAU?$nsReadableFragment@G@@W4nsFragmentRequest@@I@Z ; 5909 +?ShiftDoubleCharsLeft@@YAXPADIII@Z ; 5858 +?Clone@nsProxyEventKey@@UBEPAVnsHashKey@@XZ ; 5832 +?IsManagerShutdown@nsProxyObjectManager@@SAHXZ ; 5823 +?ReleaseService@nsServiceManager@@SAIABUnsID@@PAVnsISupports@@PAVnsIShutdownListener@@@Z ; 5681 +??4nsSimpleCharString@@QAEXABV0@@Z ; 5572 +?Copy@nsXPIDLString@@SAPAGPBG@Z ; 5526 +??0nsString@@QAE@PBG@Z ; 5504 +?Find@nsProxyEventObject@@QAEPAV1@ABUnsID@@@Z ; 5501 +?WriteSegments@nsPipeOutputStream@nsPipe@@UAGIP6GIPAVnsIOutputStream@@PAXPADIIPAI@Z1I3@Z ; 5497 +?Read@StringUnicharInputStream@@UAGIPAGIIPAI@Z ; 5482 +?WriteFrom@nsPipeOutputStream@nsPipe@@UAGIPAVnsIInputStream@@IPAI@Z ; 5388 +?ToNewCString@nsString@@QBEPADXZ ; 5351 +?Release@nsInputStreamTee@@UAGKXZ ; 5341 +?IndexOf@nsSupportsArray@@UAGHPBVnsISupports@@@Z ; 5281 +?IndexOfStartingAt@nsSupportsArray@@UAGHPBVnsISupports@@I@Z ; 5281 +??6nsOutputStream@@QAEAAV0@PBD@Z ; 5112 +?ToInteger@nsCString@@QBEHPAHI@Z ; 5109 +?do_AssignFromElementPtrLength@nsACString@@MAEXPBDI@Z ; 5103 +?Exists@nsLocalFile@@UAGIPAH@Z ; 5085 +?PL_HashTableInit@@YA?AW4PRStatus@@PAUPLHashTable@@IP6AIPBX@ZP6AH11@Z3PBUPLHashAllocOps@@PAX@Z ; 4964 +??0nsHashtable@@QAE@IH@Z ; 4964 +?Get@nsInt2StrHashtable@@QAEPADI@Z ; 4864 +??BnsSimpleCharString@@QAEPADXZ ; 4785 +?GetConstant@xptiInterfaceInfo@@UAGIGPAPBVnsXPTConstant@@@Z ; 4716 +?PL_HashTableFinalize@@YAXPAUPLHashTable@@@Z ; 4596 +??1nsHashtable@@UAE@XZ ; 4596 +?do_AssignFromElementPtrLength@nsAString@@MAEXPBGI@Z ; 4541 +?Error@nsFileSpec@@QBEIXZ ; 4535 +?GetSpecialEventQueue@nsEventQueueServiceImpl@@UAGIHPAPAVnsIEventQueue@@@Z ; 4454 +?GetStringProperty@nsPersistentProperties@@UAGIABVnsString@@AAV2@@Z ; 4441 +?DumpStatistics@nsTraceRefcnt@@SAIW4StatisticsType@1@PAU_iobuf@@@Z ; 4434 +?GetBufferHandle@nsPrivateSharableString@@UBEPBV?$nsBufferHandle@G@@XZ ; 4434 +?Release@xptiInterfaceInfoManager@@UAGKXZ ; 4417 +?Clone@nsCStringKey@@UBEPAVnsHashKey@@XZ ; 4332 +?normalize_backward@?$nsWritingIterator@D@@QAEXXZ ; 4288 +??1nsFileSpec@@UAE@XZ ; 4256 +?AddRef@BasicStringImpl@@UAGKXZ ; 4185 +??_EnsCStringKey@@UAEPAXI@Z ; 4173 +?ToCString@nsCString@@QBEPADPADII@Z ; 4056 +?First@nsDequeIterator@@QAEAAV1@XZ ; 4049 +??_EnsSubsumeStr@@UAEPAXI@Z ; 4048 +?InsertStringAt@nsStringArray@@QAEHABVnsAString@@H@Z ; 4026 +?Release@BasicStringImpl@@UAGKXZ ; 3967 +?ReleaseValues@nsProperties@@SAHPAVnsHashKey@@PAX1@Z ; 3966 +?StripChars2@@YAHPADIPBD@Z ; 3927 +?ToFloat@nsString@@QBEMPAH@Z ; 3910 +?Release@nsThreadPool@@UAGKXZ ; 3896 +??0nsPromiseFlatCString@@IAE@ABVnsACString@@@Z ; 3888 +??1nsPromiseFlatCString@@UAE@XZ ; 3878 +?Clone@nsStringKey@@UBEPAVnsHashKey@@XZ ; 3824 +?RFindChar2@@YAHPBDIHGHH@Z ; 3738 +??_EnsStringKey@@UAEPAXI@Z ; 3721 +?Alloc@ArenaImpl@@UAGPAXI@Z ; 3688 +?DeleteFirstSegment@nsSegmentedBuffer@@QAEHXZ ; 3646 +?OpenANSIFileDesc@nsLocalFile@@UAGIPBDPAPAU_iobuf@@@Z ; 3547 +?EqualsWithConversion@nsCString@@QBEHPBDHH@Z ; 3544 +?EqualsIgnoreCase@nsCString@@QBEHPBDH@Z ; 3544 +?ResolvePath@nsLocalFile@@AAEIPBDHPAPAD@Z ; 3539 +?CopyFrom@nsSimpleCharString@@QAEXPBDI@Z ; 3498 +?FindCharInReadable@@YAHGAAV?$nsReadingIterator@G@@ABV1@@Z ; 3480 +??0nsPromiseSubstring@@QAE@ABV?$nsReadingIterator@G@@0@Z ; 3431 +?GetStringUTF8@nsRegistry@@UAGIIPBDPAPAD@Z ; 3345 +??0nsSegmentedBuffer@@QAE@XZ ; 3334 +??1nsSegmentedBuffer@@QAE@XZ ; 3333 +?GetInfoForName@xptiInterfaceInfoManager@@UAGIPBDPAPAVnsIInterfaceInfo@@@Z ; 3332 +?Init@nsSegmentedBuffer@@QAEIIIPAVnsIMemory@@@Z ; 3307 +?HasInterfaceRecord@xptiInterfaceInfo@@QBEHXZ ; 3300 +?Compare@@YAHABVnsACString@@0@Z ; 3236 +?vsmprintf@nsTextFormatter@@SAPAGPBGPAD@Z ; 3228 +?smprintf@nsTextFormatter@@SAPAGPBGZZ ; 3228 +?QueryInterface@nsMemoryImpl@@UAGIABUnsID@@PAPAX@Z ; 3156 +??0nsPipe@@QAE@XZ ; 3153 +?Close@nsPipeOutputStream@nsPipe@@UAGIXZ ; 3153 +?SetObserver@nsPipeInputStream@nsPipe@@UAGIPAVnsIInputStreamObserver@@@Z ; 3153 +?Initialize@nsPipe@@UAGIIIHHPAVnsIMemory@@@Z ; 3153 +?NS_NewPipe@@YAIPAPAVnsIInputStream@@PAPAVnsIOutputStream@@IIHHPAVnsIMemory@@@Z ; 3153 +?Close@nsPipeInputStream@nsPipe@@UAGIXZ ; 3152 +??1nsPipe@@UAE@XZ ; 3152 +??_GnsPipe@@UAEPAXI@Z ; 3152 +?GetLeafName@nsLocalFile@@UAGIPAPAD@Z ; 3138 +?Parse@nsID@@QAEHPBD@Z ; 3088 +?GetLeaf@nsSimpleCharString@@QBEPADD@Z ; 3070 +?GetLeafName@nsFileSpec@@QBEPADXZ ; 3070 +?Flush@nsPipeOutputStream@nsPipe@@UAGIXZ ; 3043 +?CheckForDeactivation@nsEventQueueImpl@@AAEXXZ ; 3018 +?RFindChar1@@YAHPBDIHGHH@Z ; 3015 +??0nsCAutoString@@QAE@ABVnsACString@@@Z ; 3014 +?GetNext@nsDirEnumerator@@UAGIPAPAVnsISupports@@@Z ; 2976 +?ProcessPendingEvents@nsEventQueueImpl@@UAGIXZ ; 2951 +?GetInterfaceInfoManagerNoAddRef@xptiInterfaceInfoManager@@SAPAV1@XZ ; 2948 +?CountChar@nsAString@@QBEIG@Z ; 2937 +?AppendInt@nsString@@QAEXHH@Z ; 2922 +?ToUpperCase@nsString@@QAEXXZ ; 2900 +nsUnescapeCount ; 2828 +nsUnescape ; 2828 +??0nsSimpleCharString@@QAE@ABV0@@Z ; 2795 +??4nsFileSpec@@QAEXABV0@@Z ; 2739 +??0nsFileSpec@@QAE@ABV0@@Z ; 2731 +?StripWhitespace@nsString@@QAEXXZ ; 2714 +XPTI_GetInterfaceInfoManager ; 2696 +?StringAt@nsStringArray@@QBEPAVnsString@@H@Z ; 2681 +??0nsArrayEnumerator@@QAE@PAVnsISupportsArray@@@Z ; 2637 +??1nsArrayEnumerator@@UAE@XZ ; 2637 +?GetPRThread@nsThread@@UAGIPAPAUPRThread@@@Z ; 2623 +?GetMainThread@nsIThread@@SAIPAPAV1@@Z ; 2622 +NS_NewArrayEnumerator ; 2582 +??_EnsArrayEnumerator@@UAEPAXI@Z ; 2582 +?CallQueryInterfaceOnProxy@nsProxyEventClass@@AAEIPAVnsProxyEventObject@@ABUnsID@@PAPAV2@@Z ; 2571 +?GetQueue@nsProxyEventObject@@QBEPAVnsIEventQueue@@XZ ; 2571 +?DelegatedQueryInterface@nsProxyEventClass@@UAGIPAVnsProxyEventObject@@ABUnsID@@PAPAX@Z ; 2571 +?GetRealObject@nsProxyEventObject@@QBEPAVnsISupports@@XZ ; 2571 +??_EnsWeakReference@@EAEPAXI@Z ; 2556 +?ReadSegments@ConstCharImpl@@MAGIP6GIPAVnsIInputStream@@PAXPBDIIPAI@Z1I3@Z ; 2520 +?IsDone@nsRegSubtreeEnumerator@@UAGIXZ ; 2490 +?Next@nsRegSubtreeEnumerator@@UAGIXZ ; 2490 +?advance@nsRegSubtreeEnumerator@@MAGIXZ ; 2451 +?GetErrorStringBundleKey@nsErrorService@@UAGIIPAPAD@Z ; 2432 +?GetErrorStringBundle@nsErrorService@@UAGIFPAPAD@Z ; 2432 +?GetIndexOf@nsSupportsArray@@UAGIPAVnsISupports@@PAH@Z ; 2409 +?ToNewUnicode@nsCString@@QBEPAGXZ ; 2376 +?ToNewCString@@YAPADABVnsACString@@@Z ; 2364 +?copy_string@@YAAAPADAAV?$nsReadingIterator@D@@ABV1@AAPAD@Z ; 2364 +?WriteSegmentFun@nsInputStreamTee@@CGIPAVnsIInputStream@@PAXPBDIIPAI@Z ; 2346 +?CurrentItemInPlaceUTF8@nsRegSubtreeEnumerator@@UAGIPAIPAPBD@Z ; 2320 +PL_DHashAllocTable ; 2253 +?Release@nsFileSpecImpl@@UAGKXZ ; 2241 +?GetSharedBufferHandle@nsCommonCString@@MBEPBV?$nsSharedBufferHandle@D@@XZ ; 2217 +?assign@nsCommonString@@IAEXABVnsAString@@@Z ; 2217 +?ReleaseReference@?$nsSharedBufferHandle@G@@QBEXXZ ; 2217 +?NS_AllocateContiguousHandleWithData@@YAPAV?$nsSharedBufferHandle@G@@PBV1@ABVnsAString@@I@Z ; 2217 +?QueryInterface@nsFileSpecImpl@@UAGIABUnsID@@PAPAX@Z ; 2172 +?GetRequest@nsThreadPool@@QAEPAVnsIRunnable@@PAVnsIThread@@@Z ; 2147 +PL_DHashFreeTable ; 2125 +?Clear@nsCStringArray@@QAEXXZ ; 2122 +?ReadSegments@nsInputStreamTee@@UAGIP6GIPAVnsIInputStream@@PAXPBDIIPAI@Z1I3@Z ; 2115 +?TeeSegment@nsInputStreamTee@@AAEIPBDI@Z ; 2045 +?DispatchRequest@nsThreadPool@@UAGIPAVnsIRunnable@@@Z ; 2038 +??1nsThreadPoolBusyBody@@QAE@XZ ; 2038 +??0nsThreadPoolBusyBody@@QAE@PAVnsThreadPool@@@Z ; 2038 +??0nsCreateInstanceByCID@@QAE@ABUnsID@@PAVnsISupports@@PAI@Z ; 2029 +?ReplaceChar@nsCString@@QAEXGG@Z ; 2022 +?CloseStream@nsFileSpecImpl@@UAGIXZ ; 1968 +?do_InsertFromReadable@nsACString@@MAEXABV1@I@Z ; 1965 +?do_InsertFromElement@nsACString@@MAEXDI@Z ; 1965 +??_EnsFileSpecImpl@@UAEPAXI@Z ; 1955 +??1nsFileSpecImpl@@UAE@XZ ; 1955 +??0nsSimpleCharString@@QAE@PBD@Z ; 1936 +?RFindCharInSet@nsCString@@QBEHPBDH@Z ; 1913 +?RFindCharInSet@nsStr@@SAHABU1@0HH@Z ; 1913 +?Release@ByteBufferImpl@@UAGKXZ ; 1905 +?SkipWhiteSpace@nsPersistentProperties@@QAEHH@Z ; 1898 +?First@nsACString@@QBEDXZ ; 1881 +??0nsVoidArray@@QAE@H@Z ; 1876 +?copy_string_backward@@YAAAV?$nsWritingIterator@D@@ABV?$nsReadingIterator@D@@AAV2@AAV1@@Z ; 1834 +?QueryInterface@nsPipeInputStream@nsPipe@@UAGIABUnsID@@PAPAX@Z ; 1782 +?QueryInterface@nsPipe@@UAGIABUnsID@@PAPAX@Z ; 1782 +?CountCharInReadable@@YAIABVnsAString@@G@Z ; 1767 +?IsDirectory@nsLocalFile@@UAGIPAH@Z ; 1765 +?GetFileSpec@nsFileSpecImpl@@UAGIPAVnsFileSpec@@@Z ; 1765 +?CopyUnicodeTo@@YAPAGABVnsAString@@IPAGI@Z ; 1749 +NS_QuickSort ; 1729 +??1nsStringArray@@UAE@XZ ; 1709 +??0nsStringArray@@QAE@XZ ; 1709 +?IsScriptable@xptiInterfaceInfo@@UAGIPAH@Z ; 1690 +?Find@nsCString@@QBEHPBGHHH@Z ; 1674 +?SetLeafName@nsFileSpec@@QAEXPBD@Z ; 1670 +?LeafReplace@nsSimpleCharString@@QAEXDPBD@Z ; 1670 +?NextLine@ManifestLineReader@@QAEHXZ ; 1658 +??0nsFileSpec@@QAE@XZ ; 1656 +PL_DHashTableInit ; 1622 +??4nsSimpleCharString@@QAEXPBD@Z ; 1598 +?GetInterfaceIsArgNumberForParam@xptiInterfaceInfo@@UAGIGPBVnsXPTParamInfo@@PAE@Z ; 1555 +?Init@nsInputStreamTee@@UAGIPAVnsIInputStream@@PAVnsIOutputStream@@@Z ; 1550 +?QueryInterface@nsInputStreamTee@@UAGIABUnsID@@PAPAX@Z ; 1550 +?Right@nsAString@@QBEIAAV1@I@Z ; 1518 +PL_DHashTableFinish ; 1494 +??0nsFileSpecImpl@@QAE@ABVnsFileSpec@@@Z ; 1446 +?MakeInterface@nsFileSpecImpl@@SAIABVnsFileSpec@@PAPAVnsIFileSpec@@@Z ; 1446 +?NS_NewFileSpecWithSpec@@YAIABVnsFileSpec@@PAPAVnsIFileSpec@@@Z ; 1437 +??0xptiInterfaceInfo@@QAE@PBDABUnsID@@ABVxptiTypelib@@PAVxptiWorkingSet@@@Z ; 1434 +?CopyName@xptiInterfaceInfo@@AAEXPBDPAVxptiWorkingSet@@@Z ; 1434 +?SetScriptableFlag@xptiInterfaceInfo@@QAEXH@Z ; 1434 +??1xptiInterfaceInfo@@UAE@XZ ; 1427 +??_GxptiInterfaceInfo@@UAEPAXI@Z ; 1427 +??1nsSupportsHashtable@@UAE@XZ ; 1406 +??0nsACString@@QAE@XZ ; 1361 +?Exists@nsHashtable@@QAEHPAVnsHashKey@@@Z ; 1348 +?SetData@nsSupportsVoidImpl@@UAGIPAX@Z ; 1337 +??0BasicStringImpl@@QAE@XZ ; 1319 +?QueryInterface@BasicStringImpl@@UAGIABUnsID@@PAPAX@Z ; 1319 +??0ConstCharImpl@@QAE@PBDH@Z ; 1319 +?NewMonitor@nsAutoMonitor@@SAPAUPRMonitor@@PBD@Z ; 1312 +??1BasicStringImpl@@UAE@XZ ; 1309 +?DestroyMonitor@nsAutoMonitor@@SAXPAUPRMonitor@@@Z ; 1309 +??_EBasicStringImpl@@UAEPAXI@Z ; 1309 +?Enter@nsAutoCMonitor@@QAEXXZ ; 1307 +?Exit@nsAutoCMonitor@@QAEXXZ ; 1307 +?StringAllocator_wchar_t@@YAAAV?$nsStringAllocator@G@@XZ ; 1306 +?get_allocator@?$nsSharedBufferHandle@G@@IBEAAV?$nsStringAllocator@G@@XZ ; 1306 +?Deallocate@?$XPCOM_StringAllocator@G@@UBEXPAG@Z ; 1306 +NS_NewCharInputStream ; 1303 +?Release@nsRegSubtreeEnumerator@@UAGKXZ ; 1289 +??0nsDequeIterator@@QAE@ABVnsDeque@@H@Z ; 1284 +??FnsDequeIterator@@QAEPAXXZ ; 1284 +?End@nsDeque@@QBE?AVnsDequeIterator@@XZ ; 1284 +?OpenNSPRFileDesc@nsLocalFile@@UAGIHHPAPAUPRFileDesc@@@Z ; 1275 +?StrInsert@nsStr@@SAXAAU1@IABU1@IH@Z ; 1266 +?InsertWithConversion@nsString@@QAEXPBDIH@Z ; 1266 +?ShiftDoubleCharsRight@@YAXPADIII@Z ; 1266 +??0nsSupportsVoidImpl@@QAE@XZ ; 1260 +??_GnsSupportsVoidImpl@@UAEPAXI@Z ; 1260 +??1nsSupportsVoidImpl@@UAE@XZ ; 1260 +?QueryInterface@nsSupportsVoidImpl@@UAGIABUnsID@@PAPAX@Z ; 1260 +?QueryInterface@ConverterInputStream@@UAGIABUnsID@@PAPAX@Z ; 1258 +?get_at_eof@nsRandomAccessInputStream@@MBEHXZ ; 1241 +?GetAtEOF@FileImpl@@UAGIPAH@Z ; 1241 +?get_at_eof@nsRandomAccessStoreClient@@MBEHXZ ; 1241 +?GetTargetArraySize@nsObserverListEnumerator@@ABEIXZ ; 1208 +??YnsSimpleCharString@@QAEXPBD@Z ; 1187 +??_EStringUnicharInputStream@@UAEPAXI@Z ; 1178 +??1StringUnicharInputStream@@UAE@XZ ; 1178 +??0StringUnicharInputStream@@QAE@PAVnsString@@@Z ; 1178 +?NS_NewStringUnicharInputStream@@YAIPAPAVnsIUnicharInputStream@@PAVnsString@@@Z ; 1178 +??0nsInputStreamTee@@QAE@XZ ; 1164 +??_GnsInputStreamTee@@UAEPAXI@Z ; 1164 +??1nsInputStreamTee@@UAE@XZ ; 1164 +?NS_NewInputStreamTee@@YAIPAPAVnsIInputStream@@PAV1@PAVnsIOutputStream@@@Z ; 1164 +?GetTypelibRecord@xptiInterfaceInfo@@QBEABVxptiTypelib@@XZ ; 1156 +?Write@nsStorageStream@@UAGIPBDIPAI@Z ; 1138 +?GetObserverList@nsObserverService@@EAGIPBGPAPAVnsIObserverList@@@Z ; 1119 +?HasMoreElements@nsArrayEnumerator@@UAGIPAH@Z ; 1100 +?GetCString@nsFileSpec@@QBEPBDXZ ; 1098 +PL_DHashVoidPtrKeyStub ; 1098 +?strtok@nsCRT@@SAPADPADPBDPAPAD@Z ; 1084 +?GetInfoForIID@xptiInterfaceInfoManager@@UAGIPBUnsID@@PAPAVnsIInterfaceInfo@@@Z ; 1081 +??_EnsSupportsArrayEnumerator@@UAEPAXI@Z ; 1065 +??0nsSupportsArrayEnumerator@@QAE@PAVnsISupportsArray@@@Z ; 1065 +??1nsSupportsArrayEnumerator@@UAE@XZ ; 1065 +?Enumerate@nsSupportsArray@@UAGIPAPAVnsIEnumerator@@@Z ; 1065 +?First@nsSupportsArrayEnumerator@@UAGIXZ ; 1065 +?WriteFully@nsBinaryOutputStream@@QAEIPBDI@Z ; 1055 +?CurrentItem@nsSupportsArrayEnumerator@@UAGIPAPAVnsISupports@@@Z ; 1053 +?GetConstantCount@xptiInterfaceInfo@@UAGIPAG@Z ; 1040 +?Clone@nsIDKey@@UBEPAVnsHashKey@@XZ ; 1035 +?SetStringProperty@nsPersistentProperties@@UAGIABVnsString@@AAV2@1@Z ; 1006 +?Next@nsSupportsArrayEnumerator@@UAGIXZ ; 993 +?Release@nsStorageInputStream@@UAGKXZ ; 981 +?GetMethodCount@xptiInterfaceInfo@@UAGIPAG@Z ; 970 +?QueryInterface@nsObserverService@@UAGIABUnsID@@PAPAX@Z ; 948 +?FindChar@nsAString@@QBEHGI@Z ; 941 +?LinkBuffer@nsSharedBufferList@@QAEXPAVBuffer@1@00@Z ; 920 +?IsIID@xptiInterfaceInfo@@UAGIPBUnsID@@PAH@Z ; 918 +?AppendBuffer@nsSlidingString@@QAEXPAG00@Z ; 900 +??1nsFilePath@@UAE@XZ ; 886 +?NativeToUnix@nsFileSpecHelpers@@YAXAAVnsSimpleCharString@@@Z ; 886 +?SetDeallocator@nsDeque@@QAEXPAVnsDequeFunctor@@@Z ; 885 +?IsASCII@@YAHABVnsAString@@@Z ; 875 +?SkipLine@nsPersistentProperties@@QAEHH@Z ; 862 +?EnumerateObserverList@nsObserverService@@UAGIPBGPAPAVnsIEnumerator@@@Z ; 855 +?EnumerateObserverList@nsObserverList@@UAGIPAPAVnsIEnumerator@@@Z ; 855 +??4nsPersistentFileDescriptor@@QAEXABVnsFileSpec@@@Z ; 849 +??1nsPersistentFileDescriptor@@UAE@XZ ; 849 +??0nsPersistentFileDescriptor@@QAE@ABVnsFileSpec@@@Z ; 849 +?GetData@nsPersistentFileDescriptor@@QBEXAAVnsSimpleCharString@@@Z ; 849 +?GetPersistentDescriptorString@nsFileSpecImpl@@UAGIPAPAD@Z ; 849 +?FindInReadable@@YAHABVnsAString@@AAV?$nsReadingIterator@G@@1@Z ; 819 +?nsCID_Destroy@@YAHPAVnsHashKey@@PAX1@Z ; 773 +?Read@nsInputStreamTee@@UAGIPADIPAI@Z ; 769 +??1nsFactoryEntry@@QAE@XZ ; 737 +?nsFactoryEntry_Destroy@@YAHPAVnsHashKey@@PAX1@Z ; 733 +??0nsFileSpecImpl@@QAE@XZ ; 726 +?NS_NewFileSpec@@YAIPAPAVnsIFileSpec@@@Z ; 726 +?Create@nsFileSpecImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 726 +?UnixToNative@nsFileSpecHelpers@@YAXAAVnsSimpleCharString@@@Z ; 719 +?Invalidate@xptiInterfaceInfo@@QAEXXZ ; 717 +?AppendWithConversion@nsCString@@QAEXPBGH@Z ; 697 +??0nsFactoryEntry@@QAE@ABUnsID@@PBD1PAVnsIComponentLoader@@@Z ; 695 +?SetInfoAt@xptiTypelibGuts@@QAEIGPAVxptiInterfaceInfo@@@Z ; 683 +PL_DHashGetKeyStub ; 678 +PL_DHashMoveEntryStub ; 678 +?GrowCapacity@nsDeque@@AAEAAV1@XZ ; 673 +?AssignWithConversion@nsString@@QAEXPBDH@Z ; 665 +??4nsFilePath@@QAEXABVnsFileSpec@@@Z ; 659 +??0nsFilePath@@QAE@ABVnsFileSpec@@@Z ; 659 +?Canonify@nsFileSpecHelpers@@YAXAAVnsSimpleCharString@@H@Z ; 653 +?FromFileSpec@nsFileSpecImpl@@UAGIPBVnsIFileSpec@@@Z ; 652 +?GetValueType@nsRegistry@@UAGIIPBDPAI@Z ; 652 +?GetBytesUTF8@nsRegistry@@UAGIIPBDPAIPAPAE@Z ; 651 +?Write32@nsBinaryOutputStream@@UAGII@Z ; 649 +?EnumerateBackwards@nsSupportsArray@@UAGHP6AHPAVnsISupports@@PAX@Z1@Z ; 648 +?SetFromFileSpec@nsFileSpecImpl@@UAGIABVnsFileSpec@@@Z ; 634 +?smprintf_free@nsTextFormatter@@SAXPAG@Z ; 623 +?nsEndl@@YAAAVnsOutputStream@@AAV1@@Z ; 615 +?QueryInterface@nsGenericFactory@@UAGIABUnsID@@PAPAX@Z ; 606 +?Equals@nsAString@@QBEHPBG@Z ; 599 +?strcasecmp@nsCRT@@SAHPBGPBD@Z ; 585 +?put@nsOutputStream@@QAEXD@Z ; 572 +?IsFile@nsLocalFile@@UAGIPAH@Z ; 570 +?ForEach@nsDeque@@QBEXAAVnsDequeFunctor@@@Z ; 558 +?Release@EmptyEnumeratorImpl@@UAGKXZ ; 553 +NS_NewEmptyEnumerator ; 553 +?HasMoreElements@EmptyEnumeratorImpl@@UAGIPAH@Z ; 552 +?AddRef@FileImpl@@UAGKXZ ; 549 +?Release@FileImpl@@UAGKXZ ; 542 +?snprintf@nsTextFormatter@@SAIPAGIPBGZZ ; 534 +?vsnprintf@nsTextFormatter@@SAIPAGIPBGPAD@Z ; 534 +?Available@nsPipeInputStream@nsPipe@@UAGIPAI@Z ; 533 +?PushFront@nsDeque@@QAEAAV1@PAX@Z ; 522 +?AddItem@nsAVLTree@@QAE?AW4eAVLStatus@@PAX@Z ; 518 +??0nsAutoString@@QAE@PBGH@Z ; 509 +?IsDone@nsObserverListEnumerator@@UAGIXZ ; 479 +?MoveToIndex@nsObserverListEnumerator@@AAEII@Z ; 479 +?ReleaseService@nsServiceManager@@SAIPBDPAVnsISupports@@PAVnsIShutdownListener@@@Z ; 477 +?ReleaseService@nsServiceManagerImpl@@UAGIPBDPAVnsISupports@@PAVnsIShutdownListener@@@Z ; 477 +?AppendWithConversion@nsCString@@QAEXABVnsAString@@@Z ; 467 +?CreateDll@nsNativeComponentLoader@@AAEIPAVnsIFile@@PBDPA_J2PAPAVnsDll@@@Z ; 466 +?Flush@FileImpl@@UAGIXZ ; 455 +??1nsNSPRPath@@UAE@XZ ; 444 +??BnsNSPRPath@@QBEPBDXZ ; 444 +??0nsByteArrayInputStream@@QAE@PADI@Z ; 443 +??_EnsByteArrayInputStream@@UAEPAXI@Z ; 443 +??1nsByteArrayInputStream@@UAE@XZ ; 443 +?QueryInterface@nsByteArrayInputStream@@UAGIABUnsID@@PAPAX@Z ; 443 +?NS_NewByteArrayInputStream@@YAIPAPAVnsIByteArrayInputStream@@PADK@Z ; 443 +PL_DHashMatchEntryStub ; 442 +?ScriptableFlagIsValid@xptiInterfaceInfo@@ABEHXZ ; 439 +?PartiallyResolveLocked@xptiInterfaceInfo@@QAEHPAUXPTInterfaceDescriptor@@PAVxptiWorkingSet@@@Z ; 439 +??1xptiInterfaceGuts@@QAE@XZ ; 439 +?QueryInterface@FileImpl@@UAGIABUnsID@@PAPAX@Z ; 433 +??1xptiFile@@QAE@XZ ; 424 +?QueryInterface@nsSupportsStringImpl@@UAGIABUnsID@@PAPAX@Z ; 422 +?ReplaceChar@nsString@@QAEXGG@Z ; 421 +?Notify@nsObserverService@@UAGIPAVnsISupports@@PBG1@Z ; 416 +??0nsSlidingString@@QAE@PAG00@Z ; 408 +?NewWrappingBuffer@nsSharedBufferList@@SAPAVBuffer@1@PAG00@Z ; 408 +??0nsSlidingSubstring@@IAE@PAVnsSlidingSharedBufferList@@@Z ; 408 +??0nsCStringArray@@QAE@XZ ; 394 +??1nsCStringArray@@UAE@XZ ; 393 +??EnsDirectoryIterator@@QAEAAV0@XZ ; 377 +?Reset@nsSupportsHashtable@@QAEXXZ ; 370 +?ReadSegments@nsByteArrayInputStream@@UAGIP6GIPAVnsIInputStream@@PAXPBDIIPAI@Z1I3@Z ; 356 +?GetFileSize@nsLocalFile@@UAGIPA_J@Z ; 354 +?SetDataWithLength@nsSupportsStringImpl@@UAGIIPBD@Z ; 344 +??0nsSupportsStringImpl@@QAE@XZ ; 344 +??1nsSupportsStringImpl@@UAE@XZ ; 337 +??_EnsSupportsStringImpl@@UAEPAXI@Z ; 337 +?GetModule@nsDll@@QAEIPAVnsISupports@@PAPAVnsIModule@@@Z ; 331 +?Release@nsStorageStream@@UAGKXZ ; 328 +?Release@nsSupportsIDImpl@@UAGKXZ ; 327 +?CopyASCIItoUCS2@@YAXABVnsACString@@AAVnsAString@@@Z ; 327 +?copy_string@@YAAAV?$LossyConvertEncoding@DG@@AAV?$nsReadingIterator@D@@ABV2@AAV1@@Z ; 327 +??_EnsCString@@UAEPAXI@Z ; 324 +?StringAt@nsStringArray@@QBEXHAAVnsAString@@@Z ; 321 +?ToString@nsID@@QBEPADXZ ; 319 +?GetLength@UnicharBufferImpl@@UBGHXZ ; 316 +?Fill@ByteBufferImpl@@UAGHPAIPAVnsIInputStream@@I@Z ; 316 +?Fill@ConverterInputStream@@IAEHPAI@Z ; 316 +?copy_string_backward@@YAAAV?$nsWritingIterator@G@@ABV?$nsReadingIterator@G@@AAV2@AAV1@@Z ; 310 +?do_InsertFromReadable@nsAString@@MAEXABV1@I@Z ; 310 +??0nsFileSpec@@QAE@PBDH@Z ; 307 +?SetData@nsSupportsStringImpl@@UAGIPBD@Z ; 295 +?InsertCStringAt@nsCStringArray@@QAEHABVnsCString@@H@Z ; 288 +??YnsFileSpec@@QAEXPBD@Z ; 281 +?CompressWhitespace@nsCString@@QAEXHH@Z ; 278 +?GetFactory@nsNativeComponentLoader@@UAGIABUnsID@@PBD1PAPAVnsIFactory@@@Z ; 273 +?GetFactoryFromModule@nsNativeComponentLoader@@AAEIPAVnsDll@@ABUnsID@@PAPAVnsIFactory@@@Z ; 273 +?GetReadableFragment@nsPromiseConcatenation@@MBEPBGAAU?$nsReadableFragment@G@@W4nsFragmentRequest@@I@Z ; 268 +?Load@nsDll@@QAEHXZ ; 254 +?HasMoreElements@nsAdapterEnumerator@@UAGIPAH@Z ; 251 +?Next@nsObserverListEnumerator@@UAGIXZ ; 250 +??0nsSubsumeStr@@QAE@XZ ; 250 +?Subsume@nsSubsumeStr@@QAEHPAGHH@Z ; 250 +?CurrentItem@nsObserverListEnumerator@@UAGIPAPAVnsISupports@@@Z ; 250 +?Release@nsRegistryNode@@UAGKXZ ; 245 +?PrepareEncoder@nsFSStringConversion@@CAIXZ ; 241 +?UCSToNewFS@nsFSStringConversion@@SAIPBGPAPAD@Z ; 241 +?Write@nsBinaryOutputStream@@UAGIPBDIPAI@Z ; 238 +?IsDirectory@nsFileSpec@@QBEHXZ ; 236 +?QueryInterface@nsConjoiningEnumerator@@UAGIABUnsID@@PAPAX@Z ; 236 +_DllMain@12 ; 235 +??_GnsObserverListEnumerator@@UAEPAXI@Z ; 229 +?First@nsObserverListEnumerator@@UAGIXZ ; 229 +??0nsObserverListEnumerator@@QAE@PAVnsISupportsArray@@@Z ; 229 +?SetComponentInfo@nsGenericFactory@@UAGIPAUnsModuleComponentInfo@@@Z ; 228 +?NS_NewGenericFactory@@YAIPAPAVnsIGenericFactory@@PAUnsModuleComponentInfo@@@Z ; 228 +?Create@nsGenericFactory@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 228 +??0nsGenericFactory@@QAE@PAUnsModuleComponentInfo@@@Z ; 228 +?do_InsertFromElementPtrLength@nsAString@@MAEXPBGII@Z ; 227 +??1nsGenericFactory@@UAE@XZ ; 226 +?GetBufferSize@ByteBufferImpl@@UBGIXZ ; 226 +??_EnsGenericFactory@@UAEPAXI@Z ; 226 +??4nsFileSpec@@QAEXABVnsFilePath@@@Z ; 219 +?GetLastModifiedTime@nsLocalFile@@UAGIPA_J@Z ; 217 +?RFindInReadable@@YAHABVnsAString@@AAV?$nsReadingIterator@G@@1@Z ; 217 +?GetTarget@nsLocalFile@@UAGIPAPAD@Z ; 216 +?CopyFields@xptiFile@@AAEXABV1@@Z ; 212 +??0xptiFile@@QAE@XZ ; 212 +?ConvertStringLineBreaks@nsLinebreakConverter@@SAIAAVnsString@@W4ELinebreakType@1@1@Z ; 212 +??0xptiFile@@QAE@ABVnsInt64@@0PBDPAVxptiWorkingSet@@PAUXPTHeader@@@Z ; 212 +?QueryInterface@nsDirectoryService@@UAGIABUnsID@@PAPAX@Z ; 211 +?ReplaceSubstring@nsString@@QAEXABV1@0@Z ; 210 +?GetLongLong@nsRegistry@@UAGIIPBDPA_J@Z ; 210 +??0nsSimpleCharString@@QAE@ABVnsString@@@Z ; 209 +PL_DHashClearEntryStub ; 209 +??4nsSimpleCharString@@QAEXABVnsString@@@Z ; 209 +?Release@nsDirectoryService@@UAGKXZ ; 208 +?GetType@xptiFileType@@SA?AW4Type@1@PBD@Z ; 208 +?AutoRegisterComponent@nsNativeComponentLoader@@UAGIHPAVnsIFile@@PAH@Z ; 208 +?SetLeafName@nsFileSpecImpl@@UAGIPBD@Z ; 207 +?SetLeafName@nsFileSpec@@QAEXABVnsString@@@Z ; 203 +??0nsFilePath@@QAE@ABVnsString@@H@Z ; 203 +nsEscapeHTML ; 200 +?SetActivityIsLegal@nsTraceRefcnt@@SAXH@Z ; 198 +?GetProxy@nsCWeakReferent@@QAEPAVnsCWeakProxy@@XZ ; 196 +??0nsCWeakProxy@@QAE@PAXPAVnsCWeakReferent@@@Z ; 196 +??0nsCWeakReferent@@QAE@PAX@Z ; 196 +?ReleaseReference@nsCWeakProxy@@QAEXXZ ; 195 +??_EnsCWeakProxy@@UAEPAXI@Z ; 195 +??1nsCWeakProxy@@UAE@XZ ; 195 +??1nsCWeakReferent@@UAE@XZ ; 195 +nsEscape ; 178 +nsEscapeCount ; 178 +?GetIsOpen@FileImpl@@UAGIPAH@Z ; 177 +?Exists@nsFileSpec@@QBEHXZ ; 173 +?read@nsInputStream@@QAEHPAXH@Z ; 171 +?Read@FileImpl@@UAGIPADIPAI@Z ; 171 +??0nsAutoString@@QAE@G@Z ; 170 +?GetClassObject@nsGenericModule@@UAGIPAVnsIComponentManager@@ABUnsID@@1PAPAX@Z ; 169 +?Get@nsDirectoryService@@UAGIPBDABUnsID@@PAPAX@Z ; 165 +?Seek@nsStorageStream@@AAGIH@Z ; 164 +?SetLength@nsStorageStream@@UAGII@Z ; 164 +?Close@FileImpl@@UAGIXZ ; 163 +?WriteStringZ@nsBinaryOutputStream@@UAGIPBD@Z ; 163 +?AppendElements@nsSupportsArray@@UAGHPAVnsISupportsArray@@@Z ; 162 +?Write8@nsBinaryOutputStream@@UAGIE@Z ; 162 +?AddObserver@nsObserverService@@UAGIPAVnsIObserver@@PBG@Z ; 158 +?AddObserver@nsObserverList@@UAGIPAVnsIObserver@@@Z ; 158 +?read@ConstCharImpl@@MAEHPADI@Z ; 156 +?Read@BasicStringImpl@@UAGIPADIPAI@Z ; 156 +?GetGlobalMemoryService@nsMemory@@SAPAVnsIMemory@@XZ ; 155 +?GetData@nsSupportsStringImpl@@UAGIPAPAD@Z ; 153 +??0nsCAutoString@@QAE@PBDH@Z ; 152 +??0nsObjectHashtable@@QAE@P6APAXPAVnsHashKey@@PAX1@Z1P6AH011@Z1IH@Z ; 140 +??0ArenaImpl@@QAE@XZ ; 139 +?Init@ArenaImpl@@UAGII@Z ; 139 +?Create@ArenaImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 139 +?NS_NewHeapArena@@YAIPAPAVnsIArena@@I@Z ; 139 +?QueryInterface@ArenaImpl@@UAGIABUnsID@@PAPAX@Z ; 139 +??1nsObjectHashtable@@UAE@XZ ; 138 +?Reset@nsObjectHashtable@@QAEXXZ ; 138 +?ResolveLocked@xptiInterfaceInfo@@AAEHPAVxptiWorkingSet@@@Z ; 129 +?GetNext@nsAdapterEnumerator@@UAGIPAPAVnsISupports@@@Z ; 129 +?GetCompleted@nsProxyObjectCallInfo@@QAEHXZ ; 124 +??0CBufDescriptor@@QAE@PBGHIH@Z ; 123 +??0nsServiceEntry@@QAE@ABUnsID@@PAVnsISupports@@@Z ; 122 +?NotifyListeners@nsServiceEntry@@QAEIXZ ; 122 +??1nsServiceEntry@@QAE@XZ ; 122 +?Resolve@xptiInterfaceInfo@@AAEHPAVxptiWorkingSet@@@Z ; 122 +??4nsFileSpec@@QAEXPBD@Z ; 121 +?QueryInterface@nsRegistryNode@@UAGIABUnsID@@PAPAX@Z ; 114 +?RegisterThreadSelf@nsThread@@QAEIXZ ; 114 +?FindSymbol@nsDll@@QAEPAXPBD@Z ; 114 +??_GnsRegistryNode@@UAEPAXI@Z ; 114 +??0nsThread@@QAE@XZ ; 114 +??0nsRegistryNode@@QAE@PAXPADJ@Z ; 114 +?CurrentItem@nsRegSubtreeEnumerator@@UAGIPAPAVnsISupports@@@Z ; 114 +??1nsRegistryNode@@UAE@XZ ; 114 +?Init@nsThread@@UAGIPAVnsIRunnable@@IW4PRThreadPriority@@W4PRThreadScope@@W4PRThreadState@@@Z ; 113 +?NS_NewThread@@YAIPAPAVnsIThread@@PAVnsIRunnable@@IW4PRThreadState@@W4PRThreadPriority@@W4PRThreadScope@@@Z ; 113 +?WaitUntilReadyToStartMain@nsThread@@QAEXXZ ; 113 +?Main@nsThread@@SAXPAX@Z ; 113 +??1ArenaImpl@@UAE@XZ ; 112 +??_GArenaImpl@@UAEPAXI@Z ; 112 +?GetKey@nsRegistryNode@@UAGIPAI@Z ; 112 +?Exit@nsThread@@SAXPAX@Z ; 111 +??1nsThread@@UAE@XZ ; 110 +?GetCurrent@nsIThread@@SAIPAPAV1@@Z ; 110 +??_GnsThread@@UAEPAXI@Z ; 110 +?WriteToLog@xptiInterfaceInfoManager@@SAXPBDZZ ; 110 +?GetIThread@nsIThread@@SAIPAUPRThread@@PAPAV1@@Z ; 110 +?Write@nsPipeOutputStream@nsPipe@@UAGIPBDIPAI@Z ; 109 +?AddThread@nsThreadPool@@IAEIXZ ; 109 +?Run@nsThreadPoolRunnable@@UAGIXZ ; 109 +??0nsThreadPoolRunnable@@QAE@PAVnsThreadPool@@@Z ; 109 +?DeleteLastElement@nsSupportsArray@@UAGIPAVnsISupports@@@Z ; 108 +??_GnsThreadPoolRunnable@@UAEPAXI@Z ; 108 +?RemoveLastElement@nsSupportsArray@@UAGHPBVnsISupports@@@Z ; 108 +?RemoveThread@nsThreadPool@@IAEIPAVnsIThread@@@Z ; 108 +??1nsThreadPoolRunnable@@UAE@XZ ; 108 +?GetNameUTF8@nsRegistryNode@@UAGIPAPAD@Z ; 108 +?RemoveObserver@nsObserverService@@UAGIPAVnsIObserver@@PBG@Z ; 106 +?RemoveObserver@nsObserverList@@UAGIPAVnsIObserver@@@Z ; 106 +?Contains@nsLocalFile@@UAGIPAVnsIFile@@HPAH@Z ; 104 +?RegistryLocationForSpec@nsComponentManagerImpl@@UAGIPAVnsIFile@@PAPAD@Z ; 104 +?Close@ConverterInputStream@@UAGIXZ ; 103 +??1nsDll@@QAE@XZ ; 103 +?Init@nsDll@@AAEXPAVnsIFile@@@Z ; 100 +??0nsDll@@QAE@PAVnsIFile@@PBDPA_J2@Z ; 100 +?SpecForRegistryLocation@nsComponentManagerImpl@@UAGIPBDPAPAVnsIFile@@@Z ; 100 +?UnescapeKey@nsRegistry@@UAGIPAEIPAIPAPAE@Z ; 99 +?GetRegistryDllInfo@nsNativeComponentLoader@@AAEIIPA_J0@Z ; 99 +NS_NewIOFileStream ; 98 +?Open@FileImpl@@UAGIABVnsFileSpec@@HH@Z ; 98 +??1FileImpl@@UAE@XZ ; 98 +??_GFileImpl@@UAEPAXI@Z ; 98 +??0FileImpl@@QAE@ABVnsFileSpec@@HH@Z ; 98 +?HasChanged@nsDll@@QAEHXZ ; 94 +?Read@nsByteArrayInputStream@@UAGIPADIPAI@Z ; 87 +PL_DHashGetStubOps ; 86 +??0nsStorageStream@@QAE@XZ ; 83 +?NS_NewStorageStream@@YAIIIPAPAVnsIStorageStream@@@Z ; 83 +??1nsStorageStream@@UAE@XZ ; 83 +?Init@nsStorageStream@@QAGIIIPAVnsIMemory@@@Z ; 83 +??_EnsStorageStream@@UAEPAXI@Z ; 83 +?GetOutputStream@nsStorageStream@@UAGIHPAPAVnsIOutputStream@@@Z ; 82 +?WriteBytes@nsBinaryOutputStream@@UAGIPBDI@Z ; 82 +??0nsBinaryOutputStream@@QAE@PAVnsIOutputStream@@@Z ; 81 +?Write16@nsBinaryOutputStream@@UAGIG@Z ; 81 +??1nsStorageInputStream@@UAE@XZ ; 81 +?Available@nsStorageInputStream@@UAGIPAI@Z ; 81 +?NewInputStream@nsStorageStream@@UAGIHPAPAVnsIInputStream@@@Z ; 81 +??_EnsStorageInputStream@@UAEPAXI@Z ; 81 +?WriteFloat@nsBinaryOutputStream@@UAGIM@Z ; 81 +?NS_NewBinaryOutputStream@@YAIPAPAVnsIBinaryOutputStream@@PAVnsIOutputStream@@@Z ; 81 +?Release@nsBinaryOutputStream@@UAGKXZ ; 81 +??_EnsBinaryOutputStream@@UAEPAXI@Z ; 81 +?Read@nsStorageInputStream@@UAGIPADIPAI@Z ; 81 +??0nsStorageInputStream@@QAE@PAVnsStorageStream@@I@Z ; 81 +??_EConverterInputStream@@UAEPAXI@Z ; 80 +??0ByteBufferImpl@@QAE@XZ ; 80 +?QueryInterface@nsSupportsPRInt32Impl@@UAGIABUnsID@@PAPAX@Z ; 80 +?NS_NewUnicharBuffer@@YAIPAPAVnsIUnicharBuffer@@PAVnsISupports@@I@Z ; 80 +?NS_NewB2UConverter@@YAIPAPAVnsIUnicodeDecoder@@PAVnsISupports@@PAVnsString@@@Z ; 80 +?QueryInterface@UnicharBufferImpl@@UAGIABUnsID@@PAPAX@Z ; 80 +??1ByteBufferImpl@@UAE@XZ ; 80 +?Init@UnicharBufferImpl@@UAGII@Z ; 80 +??0UnicharBufferImpl@@QAE@XZ ; 80 +?Create@UnicharBufferImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 80 +?NS_NewByteBuffer@@YAIPAPAVnsIByteBuffer@@PAVnsISupports@@I@Z ; 80 +?Init@ByteBufferImpl@@UAGII@Z ; 80 +?QueryInterface@ByteBufferImpl@@UAGIABUnsID@@PAPAX@Z ; 80 +??0ConverterInputStream@@QAE@PAVnsIInputStream@@PAVnsIUnicodeDecoder@@I@Z ; 80 +??1UnicharBufferImpl@@UAE@XZ ; 80 +??_EUnicharBufferImpl@@UAEPAXI@Z ; 80 +?NS_NewConverterStream@@YAIPAPAVnsIUnicharInputStream@@PAVnsISupports@@PAVnsIInputStream@@HPAVnsString@@@Z ; 80 +??_EByteBufferImpl@@UAEPAXI@Z ; 80 +??1ConverterInputStream@@UAE@XZ ; 80 +?Create@ByteBufferImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 80 +?is_open@nsFileClient@@QBEHXZ ; 79 +?GetData@nsSupportsPRBoolImpl@@UAGIPAH@Z ; 78 +??0nsSupportsPRInt32Impl@@QAE@XZ ; 77 +?SetNativePath@nsFileSpecImpl@@UAGIPBD@Z ; 74 +?InsertFromReadable@nsAString@@IAEXABV1@I@Z ; 74 +?ToString@nsSupportsStringImpl@@UAGIPAPAD@Z ; 74 +?IsDone@nsSupportsArrayEnumerator@@UAGIXZ ; 73 +?AllocateBuffers@FileImpl@@IAEIII@Z ; 71 +??1nsOutputStream@@UAE@XZ ; 71 +??_EnsSupportsPRInt32Impl@@UAEPAXI@Z ; 70 +??1nsOutputFileStream@@UAE@XZ ; 70 +?AssignFrom@nsOutputFileStream@@IAEXPAVnsISupports@@@Z ; 70 +??0nsRandomAccessOutputStream@@IAE@XZ ; 70 +??0nsOutputStream@@QAE@PAVnsIOutputStream@@@Z ; 70 +??1nsRandomAccessOutputStream@@UAE@XZ ; 70 +??1nsSupportsPRInt32Impl@@UAE@XZ ; 70 +??0nsDirectoryIterator@@QAE@ABVnsFileSpec@@H@Z ; 68 +??1nsDirectoryIterator@@UAE@XZ ; 68 +?Promises@nsPromiseCConcatenation@@UBEHABVnsACString@@@Z ; 67 +?Length@nsPromiseConcatenation@@UBEIXZ ; 67 +?AppendFromPromise@nsAString@@IAEXABV1@@Z ; 67 +?IndexOf@nsStringArray@@QBEHABVnsAString@@@Z ; 67 +??0nsOutputFileStream@@QAE@ABVnsFileSpec@@HH@Z ; 67 +?Available@nsInputStreamTee@@UAGIPAI@Z ; 66 +?HashContractID@nsComponentManagerImpl@@IAEIPBDABUnsID@@@Z ; 65 +??0nsSubsumeCStr@@QAE@PADHH@Z ; 65 +?close@nsInputStream@@QAEIXZ ; 65 +?HandleEvent@nsEventQueueImpl@@UAGIPAUPLEvent@@@Z ; 62 +?PostAndWait@nsProxyObject@@QAEIPAVnsProxyObjectCallInfo@@@Z ; 62 +?WaitForEvent@nsEventQueueImpl@@UAGIPAPAUPLEvent@@@Z ; 62 +?SetCallersQueue@nsProxyObjectCallInfo@@QAEXPAVnsIEventQueue@@@Z ; 62 +PL_PostSynchronousEvent ; 62 +?PostSynchronousEvent@nsEventQueueImpl@@UAGIPAUPLEvent@@PAPAX@Z ; 62 +PL_WaitForEvent ; 62 +?strcmp@nsCRT@@SAHPBGPBD@Z ; 60 +?ns_file_convert_result@@YAIH@Z ; 60 +?Load@nsLocalFile@@UAGIPAPAUPRLibrary@@@Z ; 54 +?hash_enumerator@@YAHPAVnsHashKey@@PAX1@Z ; 53 +?Shutdown@nsDll@@QAEIXZ ; 53 +??1nsAdapterEnumerator@@UAE@XZ ; 51 +?IsDone@nsHashtableEnumerator@@UAGIXZ ; 51 +?CurrentItem@nsHashtableEnumerator@@UAGIPAPAVnsISupports@@@Z ; 51 +?Next@nsHashtableEnumerator@@UAGIXZ ; 51 +??0nsAdapterEnumerator@@QAE@PAVnsIEnumerator@@@Z ; 51 +??HnsFileSpec@@QBE?AV0@PBD@Z ; 50 +?Read32@nsBinaryInputStream@@UAGIPAI@Z ; 50 +?Available@nsByteArrayInputStream@@UAGIPAI@Z ; 50 +?flush@nsOutputFileStream@@UAEIXZ ; 49 +?RegisterComponentCommon@nsComponentManagerImpl@@IAEIABUnsID@@PBD11HH1@Z ; 48 +??0nsString@@QAE@AAVnsSubsumeStr@@@Z ; 47 +??0nsSubsumeStr@@QAE@PAGHH@Z ; 47 +??0CBufDescriptor@@QAE@PBDHIH@Z ; 46 +?Initialize@nsGenericModule@@IAEIXZ ; 45 +??0nsGenericModule@@QAE@PBDIPAUnsModuleComponentInfo@@P6AXPAVnsIModule@@@Z@Z ; 45 +?CanUnload@nsGenericModule@@UAGIPAVnsIComponentManager@@PAH@Z ; 45 +?Shutdown@nsGenericModule@@IAEXXZ ; 45 +?NS_NewGenericModule@@YAIPBDIPAUnsModuleComponentInfo@@P6AXPAVnsIModule@@@ZPAPAV2@@Z ; 45 +?GetLoaderForType@nsComponentManagerImpl@@IAEIPBDPAPAVnsIComponentLoader@@@Z ; 45 +?QueryInterface@nsGenericModule@@UAGIABUnsID@@PAPAX@Z ; 45 +??_EnsGenericModule@@UAEPAXI@Z ; 45 +??1nsGenericModule@@UAE@XZ ; 45 +?OnRegister@nsNativeComponentLoader@@UAGIABUnsID@@PBD111HH@Z ; 44 +?GetLeafName@nsFileSpecImpl@@UAGIPAPAD@Z ; 44 +?QueryInterface@AtomImpl@@UAGIABUnsID@@PAPAX@Z ; 44 +?find_category@nsCategoryManager@@AAEPAVCategoryNode@@PBD@Z ; 44 +?RegistryNameForLib@nsComponentManagerImpl@@IAEIPBDPAPAD@Z ; 44 +?RegisterComponentLib@nsComponentManager@@SAIABUnsID@@PBD11HH@Z ; 44 +?RegisterComponentLib@nsComponentManagerImpl@@UAGIABUnsID@@PBD11HH@Z ; 44 +?RegisterFactory@nsComponentManagerImpl@@UAGIABUnsID@@PBD1PAVnsIFactory@@H@Z ; 42 +??0nsFactoryEntry@@QAE@ABUnsID@@PAVnsIFactory@@@Z ; 42 +?copy_string@@YAAAV?$ConvertToUpperCase@G@@AAV?$nsWritingIterator@G@@ABV2@AAV1@@Z ; 40 +?ResolveSymlink@nsFileSpec@@QAEIAAH@Z ; 40 +?ToUpperCase@@YAXAAVnsAString@@@Z ; 40 +?advance@nsRegValueEnumerator@@UAGIXZ ; 39 +?Release@nsPersistentProperties@@UAGKXZ ; 39 +?ToNewString@nsString@@QBEPAV1@XZ ; 38 +?IsValid@xptiWorkingSet@@QBEHXZ ; 38 +?GetComponentsDir@xptiInterfaceInfoManager@@QAEHPAPAVnsILocalFile@@@Z ; 37 +??1xptiTypelibGuts@@QAE@XZ ; 36 +??0xptiTypelibGuts@@QAE@PAUXPTHeader@@@Z ; 36 +?LoadFile@xptiInterfaceInfoManager@@QAEHABVxptiTypelib@@PAVxptiWorkingSet@@@Z ; 36 +?SetHeader@xptiFile@@QAEHPAUXPTHeader@@@Z ; 36 +?ReadXPTFile@xptiInterfaceInfoManager@@AAEPAUXPTHeader@@PAVnsILocalFile@@PAVxptiWorkingSet@@@Z ; 36 +?ConvertBreaks@@YAPAGPBGAAHPBD2@Z ; 35 +?ConvertUnicharLineBreaksInSitu@nsLinebreakConverter@@SAIPAPAGW4ELinebreakType@1@1HPAH@Z ; 35 +?CountLinebreaks@@YAHPBGHPBD@Z ; 35 +?FindFactory@nsComponentManager@@SAIABUnsID@@PAPAVnsIFactory@@@Z ; 34 +??1nsRegistryValue@@UAE@XZ ; 32 +??_GnsRegistryValue@@UAEPAXI@Z ; 32 +?getInfo@nsRegistryValue@@IAEIXZ ; 32 +?find_leaf@CategoryNode@@QAEPAVnsCString@@PBD@Z ; 32 +??0nsRegistryValue@@QAE@PAXJK@Z ; 32 +?QueryInterface@nsRegistryValue@@UAGIABUnsID@@PAPAX@Z ; 32 +?GetNameUTF8@nsRegistryValue@@UAGIPAPAD@Z ; 32 +?AddCategoryEntry@nsCategoryManager@@UAGIPBD00HHPAPAD@Z ; 32 +?CurrentItem@nsRegValueEnumerator@@UAGIPAPAVnsISupports@@@Z ; 32 +??1nsInputFileStream@@UAE@XZ ; 29 +??YnsFileSpec@@QAEXABVnsString@@@Z ; 29 +?Release@nsAppFileLocationProvider@@UAGKXZ ; 29 +??0nsInputStream@@QAE@PAVnsIInputStream@@@Z ; 29 +??1nsRandomAccessInputStream@@UAE@XZ ; 29 +??1nsInputStream@@UAE@XZ ; 29 +?IsLowMemory@nsMemoryImpl@@UAGIPAH@Z ; 29 +??8nsFileSpec@@QBEHABV0@@Z ; 28 +?QueryInterface@nsAppFileLocationProvider@@UAGIABUnsID@@PAPAX@Z ; 27 +?copy_string@@YAAAV?$CalculateLength@D@@AAV?$nsReadingIterator@D@@ABV2@AAV1@@Z ; 26 +?Distance@@YAIABV?$nsReadingIterator@D@@0@Z ; 26 +?GetFile@nsAppFileLocationProvider@@UAGIPBDPAHPAPAVnsIFile@@@Z ; 26 +?nsLocalFileConstructor@nsLocalFile@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 26 +?GetFactoryFromNSGetFactory@nsNativeComponentLoader@@AAEIPAVnsDll@@ABUnsID@@PAVnsIServiceManager@@PAPAVnsIFactory@@@Z ; 25 +?Release@nsRegistry@@UAGKXZ ; 25 +?First@nsRegSubtreeEnumerator@@UAGIXZ ; 24 +??1nsRegSubtreeEnumerator@@UAE@XZ ; 24 +??0nsRegSubtreeEnumerator@@QAE@PAXJH@Z ; 24 +?Set@nsDirectoryService@@UAGIPBDPAVnsISupports@@@Z ; 24 +??_GnsRegSubtreeEnumerator@@UAEPAXI@Z ; 24 +??0nsPersistentProperties@@QAE@XZ ; 23 +?Load@nsPersistentProperties@@UAGIPAVnsIInputStream@@@Z ; 23 +?Create@nsPersistentProperties@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 23 +?QueryInterface@nsPersistentProperties@@UAGIABUnsID@@PAPAX@Z ; 23 +??1nsFileURL@@UAE@XZ ; 20 +?SetPersistentDescriptor@nsLocalFile@@UAGIPBD@Z ; 20 +?Close@BasicStringImpl@@UAGIXZ ; 20 +??4nsFileURL@@QAEXABVnsFilePath@@@Z ; 20 +?ReplaceElementAt@nsSupportsArray@@UAGHPAVnsISupports@@I@Z ; 20 +?NS_AllocateContiguousHandleWithData@@YAPAVBuffer@nsSharedBufferList@@PBV12@ABVnsLocalString@@I@Z ; 20 +?QueryInterface@nsRegistry@@UAGIABUnsID@@PAPAX@Z ; 19 +?SetCharAt@nsCString@@QAEHGI@Z ; 19 +??0nsSpecialSystemDirectory@@QAE@W4SystemDirectories@0@@Z ; 18 +?GetFileSize@nsFileSpec@@QBEIXZ ; 18 +?Exists@nsFileSpecImpl@@UAGIPAH@Z ; 18 +?GetSubtree@nsRegistry@@UAGIIPBDPAI@Z ; 18 +??4nsSpecialSystemDirectory@@QAEXW4SystemDirectories@0@@Z ; 18 +??1nsSpecialSystemDirectory@@UAE@XZ ; 18 +??0nsRandomAccessInputStream@@IAE@XZ ; 17 +??0nsObserverList@@QAE@XZ ; 17 +??1nsObserverList@@UAE@XZ ; 17 +?EnumerateSubtrees@nsRegistry@@UAGIIPAPAVnsIEnumerator@@@Z ; 17 +?NS_NewObserverList@@YAIPAPAVnsIObserverList@@@Z ; 17 +?AssignFrom@nsInputFileStream@@IAEXPAVnsISupports@@@Z ; 17 +??0nsInputFileStream@@QAE@ABVnsFileSpec@@HH@Z ; 17 +?QueryInterface@nsObserverList@@UAGIABUnsID@@PAPAX@Z ; 17 +??_GnsObserverList@@UAEPAXI@Z ; 17 +?Unescape@nsSimpleCharString@@QAEXXZ ; 16 +?SetCharAt@nsString@@QAEHGI@Z ; 16 +??1nsOpaqueKey@@UAE@XZ ; 16 +??1nsPersistentProperties@@UAE@XZ ; 16 +??_EnsPersistentProperties@@UAEPAXI@Z ; 16 +??0nsFilePath@@QAE@PBDH@Z ; 16 +??0nsOpaqueKey@@QAE@PBDIW4Ownership@0@@Z ; 16 +?AppendRelativeUnixPath@nsFileSpecImpl@@UAGIPBD@Z ; 15 +??0nsCString@@QAE@PBDH@Z ; 15 +?GetString@nsRegistry@@UAGIIPBGPAPAG@Z ; 15 +?SetStringUTF8@nsRegistry@@UAGIIPBD0@Z ; 15 +?SetString@nsRegistry@@UAGIIPBG0@Z ; 15 +?ReleaseElements@nsHashtableEnumerator@@EAGIXZ ; 14 +PL_GetEventQueueMonitor ; 14 +?ReadStringZ@nsBinaryInputStream@@UAGIPAPAD@Z ; 14 +?EscapeKey@nsRegistry@@UAGIPAEIPAIPAPAE@Z ; 14 +?AppendFromPromise@nsACString@@IAEXABV1@@Z ; 13 +?FindCharInReadable@@YAHDAAV?$nsReadingIterator@D@@ABV1@@Z ; 13 +??0nsPromiseCSubstring@@QAE@ABV?$nsReadingIterator@D@@0@Z ; 13 +?GetName@xptiInterfaceInfo@@UAGIPAPAD@Z ; 12 +?StartAssignmentByReference@nsXPIDLCString@@AAEPAPBDXZ ; 12 +??0nsFileURL@@QAE@ABVnsFileSpec@@@Z ; 12 +?ConvertFromFileSystemCharset@nsFileSpec@@IAEPAGPBD@Z ; 12 +?Read8@nsBinaryInputStream@@UAGIPAE@Z ; 12 +?IsHidden@nsLocalFile@@UAGIPAH@Z ; 12 +?BufferHashCode@nsCRT@@SAIPBDI@Z ; 12 +?GetFileSystemCharset@nsFileSpec@@KAXAAVnsString@@@Z ; 12 +??0nsRandomAccessStoreClient@@QAE@ABV?$nsCOMPtr@VnsIRandomAccessStore@@@@@Z ; 12 +??0nsFileClient@@QAE@ABV?$nsCOMPtr@VnsIOpenFile@@@@@Z ; 12 +?SetLongLong@nsRegistry@@UAGIIPBDPA_J@Z ; 12 +??0nsInputFileStream@@QAE@PAVnsIInputStream@@@Z ; 12 +?HashCode@nsOpaqueKey@@UBEIXZ ; 12 +??0nsRandomAccessInputStream@@QAE@PAVnsIInputStream@@@Z ; 12 +??4nsFileURL@@QAEXABVnsFileSpec@@@Z ; 12 +?AddRef@nsCategoryManager@@UAGKXZ ; 11 +?Release@nsCategoryManager@@UAGKXZ ; 11 +?GetFile@nsDirectoryService@@UAGIPBDPAHPAPAVnsIFile@@@Z ; 11 +??0nsProxyEventClass@@IAE@ABUnsID@@PAVnsIInterfaceInfo@@@Z ; 11 +?Read@nsFileSpecImpl@@UAGIPAPADHPAH@Z ; 11 +?InsertReadable@nsSlidingString@@IAEXABVnsAString@@ABV?$nsReadingIterator@G@@@Z ; 10 +NS_NewTypicalInputFileStream ; 10 +??1nsCommonCString@@UAE@XZ ; 10 +?SplitBuffer@nsSharedBufferList@@QAEXABUPosition@1@W4SplitDisposition@1@@Z ; 10 +?OpenStreamForReading@nsFileSpecImpl@@UAGIXZ ; 10 +PL_IsQueueNative ; 10 +?Release@nsRegistryFactory@@UAGKXZ ; 10 +??0ConstStringImpl@@QAE@ABVnsCString@@@Z ; 10 +?ResolveSymlink@nsFileSpecImpl@@UAGIXZ ; 10 +?IsQueueNative@nsEventQueueImpl@@UAGIPAH@Z ; 10 +??1nsACString@@UAE@XZ ; 10 +?Clone@nsVoidKey@@UBEPAVnsHashKey@@XZ ; 10 +NS_NewCStringInputStream ; 10 +?QueryInterface@nsRegSubtreeEnumerator@@UAGIABUnsID@@PAPAX@Z ; 9 +?GetFileSize@nsFileSpecImpl@@UAGIPAI@Z ; 9 +?GetTypeForParam@xptiInterfaceInfo@@UAGIGPBVnsXPTParamInfo@@GPAVnsXPTType@@@Z ; 9 +?Exists@nsDirectoryIteratorImpl@@UAGIPAH@Z ; 9 +?do_InsertFromElement@nsAString@@MAEXGI@Z ; 9 +?Create@nsDirectoryService@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 9 +?QueryInterface@nsCategoryManager@@UAGIABUnsID@@PAPAX@Z ; 9 +?GetFileContents@nsFileSpecImpl@@UAGIPAPAD@Z ; 9 +?GetTypeInArray@xptiInterfaceInfo@@EAGIPBVnsXPTParamInfo@@GPAPBUXPTTypeDescriptor@@@Z ; 9 +?IsOpen@nsRegistry@@UAGIPAH@Z ; 9 +?set_at_eof@nsRandomAccessStoreClient@@MAEXH@Z ; 8 +??0nsFilePath@@QAE@ABVnsFileURL@@@Z ; 8 +?GetLengthIsArgNumberForParam@xptiInterfaceInfo@@UAGIGPBVnsXPTParamInfo@@GPAE@Z ; 8 +?SetAtEOF@FileImpl@@UAGIH@Z ; 8 +?GetSubtreeRaw@nsRegistry@@UAGIIPBDPAI@Z ; 8 +?Delete@nsFileSpec@@QBEXH@Z ; 8 +??_EnsDirEnumerator@@UAEPAXI@Z ; 8 +??_EnsHashtable@@UAEPAXI@Z ; 8 +?ReadBytes@nsBinaryInputStream@@UAGIPAPADI@Z ; 8 +?Next@nsDirectoryIteratorImpl@@UAGIXZ ; 8 +?GetDirectoryEntries@nsLocalFile@@UAGIPAPAVnsISimpleEnumerator@@@Z ; 8 +??0nsFileURL@@QAE@PBDH@Z ; 8 +?EnumerateCategory@nsCategoryManager@@UAGIPBDPAPAVnsISimpleEnumerator@@@Z ; 8 +??0nsDirEnumerator@@QAE@XZ ; 8 +?Put@nsInt2StrHashtable@@QAEIIPBD@Z ; 8 +??0nsFileSpec@@QAE@ABVnsFileURL@@@Z ; 8 +?GetCurrentSpec@nsDirectoryIteratorImpl@@UAGIPAPAVnsIFileSpec@@@Z ; 8 +?Init@nsDirEnumerator@@QAEIPAVnsILocalFile@@@Z ; 8 +??1nsDirEnumerator@@UAE@XZ ; 8 +?MakeAllDirectories@nsFileSpecHelpers@@YAXPBDH@Z ; 8 +?NotifyObservers@nsEventQueueImpl@@AAEXPBD@Z ; 8 +?Reset@nsHashtableEnumerator@@EAGIPAVnsHashtable@@P6GIPAVnsHashKey@@PAX2PAPAVnsISupports@@@Z2@Z ; 7 +NS_NewHashtableEnumerator ; 7 +?GetLeafName@nsFileSpec@@QAEXAAVnsString@@@Z ; 7 +??1nsHashtableEnumerator@@UAE@XZ ; 7 +??0CategoryNode@@QAE@XZ ; 7 +?IsASCII@nsString@@QAEHPBG@Z ; 7 +NS_NewAdapterEnumerator ; 7 +??0nsRegValueEnumerator@@QAE@PAXJ@Z ; 7 +??1nsProxyEventClass@@MAE@XZ ; 7 +?Realloc@nsMemoryImpl@@UAGPAXPAXI@Z ; 7 +?EnterMonitor@nsEventQueueImpl@@UAGIXZ ; 7 +??_EnsHashtableEnumerator@@UAEPAXI@Z ; 7 +?First@nsHashtableEnumerator@@UAGIXZ ; 7 +?RegisterErrorStringBundleKey@nsErrorService@@UAGIIPBD@Z ; 7 +?EnumerateValues@nsRegistry@@UAGIIPAPAVnsIEnumerator@@@Z ; 7 +?GetSizeIsArgNumberForParam@xptiInterfaceInfo@@UAGIGPBVnsXPTParamInfo@@GPAE@Z ; 7 +??0nsHashtableEnumerator@@QAE@PAVnsHashtable@@P6GIPAVnsHashKey@@PAX2PAPAVnsISupports@@@Z2@Z ; 7 +??_EnsAdapterEnumerator@@UAEPAXI@Z ; 7 +?Release@nsComponentManagerImpl@@UAGKXZ ; 7 +??_GCategoryNode@@UAEPAXI@Z ; 7 +?Delete@nsLocalFile@@UAGIH@Z ; 7 +??_GnsProxyEventClass@@MAEPAXI@Z ; 7 +?ExitMonitor@nsEventQueueImpl@@UAGIXZ ; 7 +??0nsBinaryInputStream@@QAE@PAVnsIInputStream@@@Z ; 6 +?OpenWellKnownRegistry@nsRegistry@@UAGIH@Z ; 6 +??0nsStaticCaseInsensitiveNameTable@@QAE@XZ ; 6 +??0nsXPIDLString@@QAE@XZ ; 6 +?NS_NewBinaryInputStream@@YAIPAPAVnsIBinaryInputStream@@PAVnsIInputStream@@@Z ; 6 +?SetYounger@nsEventQueueImpl@@UAGIPAVnsPIEventQueueChain@@@Z ; 6 +?MakeUnique@nsFileSpec@@QAEXXZ ; 6 +?Release@nsBinaryInputStream@@UAGKXZ ; 6 +??_GnsBinaryInputStream@@UAEPAXI@Z ; 6 +?ConvertUnknownBreaks@@YAPADPBDAAH0@Z ; 6 +?Read16@nsBinaryInputStream@@UAGIPAG@Z ; 6 +?AddSubtreeRaw@nsRegistry@@UAGIIPBDPAI@Z ; 6 +?Init@nsStaticCaseInsensitiveNameTable@@QAEHQAPBDH@Z ; 6 +?IsFile@nsFileSpec@@QBEHXZ ; 6 +??0nsFileSpec@@QAE@ABVnsString@@H@Z ; 6 +?ConvertLineBreaks@nsLinebreakConverter@@SAPADPBDW4ELinebreakType@1@1HPAH@Z ; 6 +NS_NewByteInputStream ; 6 +?ReadFloat@nsBinaryInputStream@@UAGIPAM@Z ; 6 +?Realloc@nsMemory@@SAPAXPAXI@Z ; 6 +??1nsStaticCaseInsensitiveNameTable@@QAE@XZ ; 6 +?GetLength@nsStorageStream@@UAGIPAI@Z ; 6 +??_GnsRegistry@@UAEPAXI@Z ; 5 +??_EnsObjectHashtable@@UAEPAXI@Z ; 5 +?CloneMozBinDirectory@nsAppFileLocationProvider@@IAGIPAPAVnsILocalFile@@@Z ; 5 +?StripWhitespace@nsCString@@QAEXXZ ; 5 +??0nsRegistry@@QAE@XZ ; 5 +?MakeNewQueue@nsEventQueueServiceImpl@@EAGIPAUPRThread@@HPAPAVnsIEventQueue@@@Z ; 5 +?StopAcceptingEvents@nsEventQueueImpl@@UAGIXZ ; 5 +??1nsRegistry@@UAE@XZ ; 5 +?Create@nsEventQueueImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 5 +?Close@nsRegistry@@MAGIXZ ; 5 +?CreateInstance@nsRegistryFactory@@UAGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 5 +?InitFromPRThread@nsEventQueueImpl@@UAGIPAUPRThread@@H@Z ; 5 +??4nsFileSpec@@QAEXABVnsString@@@Z ; 5 +?NS_FileSpecToIFile@@YAIPAVnsFileSpec@@PAPAVnsILocalFile@@@Z ; 5 +?QueryInterface@nsComponentManagerImpl@@UAGIABUnsID@@PAPAX@Z ; 5 +?GetNativePathString@nsFileSpec@@QAEXAAVnsString@@@Z ; 5 +??0nsEventQueueImpl@@QAE@XZ ; 5 +?do_GetService@@YA?BVnsGetServiceByContractID@@PBDPAI@Z ; 5 +PL_EventAvailable ; 4 +?RFind@nsString@@QBEHABV1@HHH@Z ; 4 +?RegisterComponentSpec@nsComponentManagerImpl@@UAGIABUnsID@@PBD1PAVnsIFile@@HH@Z ; 4 +?FSToNewUCS@nsFSStringConversion@@SAIPBDPAPAG@Z ; 4 +?GetCategoryEntry@nsCategoryManager@@UAGIPBD0PAPAD@Z ; 4 +?RegisterComponentWithType@nsComponentManagerImpl@@UAGIABUnsID@@PBD1PAVnsIFile@@1HH1@Z ; 4 +PL_CreateNativeEventQueue ; 4 +?RemoveStringAt@nsStringArray@@QAEHH@Z ; 4 +?PrepareDecoder@nsFSStringConversion@@CAIXZ ; 4 +?GetName@nsRegistryNode@@UAGIPAPAG@Z ; 4 +?Clone@nsOpaqueKey@@UBEPAVnsHashKey@@XZ ; 4 +?SetBufferSize@nsRegistry@@QAEHH@Z ; 4 +?GetCategoryEntryRaw@nsCategoryManager@@UAGIPBD0PAPAD@Z ; 4 +?AddSubtree@nsRegistry@@UAGIIPBDPAI@Z ; 4 +??_EnsOpaqueKey@@UAEPAXI@Z ; 4 +?GetOutputStream@nsFileSpecImpl@@UAGIPAPAVnsIOutputStream@@@Z ; 3 +NS_NewTypicalOutputFileStream ; 3 +?PushThreadEventQueue@nsEventQueueServiceImpl@@UAGIPAPAVnsIEventQueue@@@Z ; 3 +?QueryInterface@nsConsoleService@@UAGIABUnsID@@PAPAX@Z ; 3 +?PopThreadEventQueue@nsEventQueueServiceImpl@@UAGIPAVnsIEventQueue@@@Z ; 3 +PL_MapEvents ; 3 +?Unlink@nsEventQueueImpl@@UAGIXZ ; 3 +?SetElder@nsEventQueueImpl@@UAGIPAVnsPIEventQueueChain@@@Z ; 3 +?AppendQueue@nsEventQueueImpl@@UAGIPAVnsIEventQueue@@@Z ; 3 +??1nsEventQueueImpl@@UAE@XZ ; 3 +?OpenStreamForWriting@nsFileSpecImpl@@UAGIXZ ; 3 +??0nsOutputFileStream@@QAE@PAVnsIFileSpec@@@Z ; 3 +?LogMessage@nsConsoleService@@UAGIPAVnsIConsoleMessage@@@Z ; 3 +PL_DestroyEventQueue ; 3 +?IsRegistered@nsComponentManagerImpl@@UAGIABUnsID@@PAH@Z ; 3 +?GetCurrentProcessDirectory@nsDirectoryService@@AAEIPAPAVnsILocalFile@@@Z ; 3 +??_EnsEventQueueImpl@@UAEPAXI@Z ; 3 +?CreateDirectory@nsFileSpec@@QAEXH@Z ; 3 +??0nsDll@@QAE@PBDH@Z ; 3 +??1nsAVLTree@@QAE@XZ ; 2 +?NewFileArray@xptiWorkingSet@@QAEHI@Z ; 2 +?ToUpper@nsCRT@@SADD@Z ; 2 +??1nsInt2StrHashtable@@UAE@XZ ; 2 +?GetUnicodeLeafName@nsLocalFile@@UAGIPAPAG@Z ; 2 +?CompareWithConversion@nsString@@QBEHABV1@HH@Z ; 2 +?Read@xptiManifest@@SAHPAVxptiInterfaceInfoManager@@PAVxptiWorkingSet@@@Z ; 2 +??0nsMemoryImpl@@QAE@XZ ; 2 +??1xptiWorkingSet@@QAE@XZ ; 2 +?Create@nsMemoryImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 2 +??0nsRegistryFactory@@QAE@XZ ; 2 +?NS_ErrorAccordingToNSPR@@YAIXZ ; 2 +?ClearHashTables@xptiWorkingSet@@QAEXXZ ; 2 +??_ExptiFile@@QAEPAXI@Z ; 2 +?AppendUnicode@nsLocalFile@@UAGIPBG@Z ; 2 +?Release@MemoryFlusher@@UAGKXZ ; 2 +??_EnsSupportsHashtable@@UAEPAXI@Z ; 2 +?CreateEventQueue@nsEventQueueServiceImpl@@EAGIPAUPRThread@@H@Z ; 2 +??1xptiAutoLog@@QAE@XZ ; 2 +NS_RegistryGetFactory ; 2 +?ClearFiles@xptiWorkingSet@@QAEXXZ ; 2 +??0xptiWorkingSet@@QAE@XZ ; 2 +?Tell@FileImpl@@UAGIPAH@Z ; 2 +?RegisterProvider@nsDirectoryService@@UAGIPAVnsIDirectoryServiceProvider@@@Z ; 2 +?GetKey@nsRegistry@@UAGIIPBGPAI@Z ; 2 +?ClearZipItems@xptiWorkingSet@@QAEXXZ ; 2 +?readline@nsRandomAccessInputStream@@QAEHPADH@Z ; 2 +??0nsAVLTree@@QAE@AAVnsAVLNodeComparitor@@PAVnsAVLNodeFunctor@@@Z ; 2 +?GetManifestDir@xptiInterfaceInfoManager@@QAEHPAPAVnsILocalFile@@@Z ; 2 +??0xptiAutoLog@@QAE@PAVxptiInterfaceInfoManager@@PAVnsILocalFile@@H@Z ; 2 +?tell@nsRandomAccessStoreClient@@QAEHXZ ; 2 +NS_NewUnicodeLocalFile ; 2 +??0nsInt2StrHashtable@@QAE@XZ ; 2 +?seek@nsRandomAccessStoreClient@@QAEXW4PRSeekWhence@@H@Z ; 2 +?Open@nsRegistry@@UAGIPBD@Z ; 2 +?QueryInterface@nsErrorService@@UAGIABUnsID@@PAPAX@Z ; 2 +?RegisterService@nsServiceManagerImpl@@UAGIABUnsID@@PAVnsISupports@@@Z ; 2 +?Seek@FileImpl@@UAGIW4PRSeekWhence@@H@Z ; 2 +?GetUnicodePath@nsLocalFile@@UAGIPAPAG@Z ; 2 +?AddRef@MemoryFlusher@@UAGKXZ ; 2 +?PrepareFSCharset@nsFSStringConversion@@CAIXZ ; 2 +??_EnsDirectoryService@@UAEPAXI@Z ; 1 +?NS_ShutdownXPCOM@@YAIPAVnsIServiceManager@@@Z ; 1 +?AutoRegister@nsComponentManagerImpl@@UAGIHPAVnsIFile@@@Z ; 1 +?OnShutdown@HandleCaseConversionShutdown3@@UAGIABUnsID@@PAVnsISupports@@@Z ; 1 +?GetParent@nsFileSpec@@QBEXAAV1@@Z ; 1 +??1nsConsoleService@@UAE@XZ ; 1 +??0nsComponentManagerImpl@@QAE@XZ ; 1 +?PlatformVersionCheck@nsComponentManagerImpl@@IAEIPAI@Z ; 1 +?PlatformInit@nsComponentManagerImpl@@IAEIXZ ; 1 +??_EnsAppFileLocationProvider@@MAEPAXI@Z ; 1 +??_EnsVoidArray@@UAEPAXI@Z ; 1 +??RnsGetServiceFromCategory@@UBEIABUnsID@@PAPAX@Z ; 1 +??0nsIOFileStream@@QAE@ABVnsFileSpec@@HH@Z ; 1 +?NS_PurgeAtomTable@@YAXXZ ; 1 +??0nsProxyObjectManager@@QAE@XZ ; 1 +?NS_NewThreadPool@@YAIPAPAVnsIThreadPool@@IIIW4PRThreadPriority@@W4PRThreadScope@@@Z ; 1 +?GetNext@EmptyEnumeratorImpl@@UAGIPAPAVnsISupports@@@Z ; 1 +??_GxptiInterfaceInfoManager@@UAEPAXI@Z ; 1 +?ReallocLastSegment@nsSegmentedBuffer@@QAEHI@Z ; 1 +??0nsNativeComponentLoader@@QAE@XZ ; 1 +?Init@nsComponentManagerImpl@@QAEIXZ ; 1 +?CreateMonitoredThreadEventQueue@nsEventQueueServiceImpl@@UAGIXZ ; 1 +?UnloadLibraries@nsComponentManagerImpl@@IAEIPAVnsIServiceManager@@H@Z ; 1 +?Run@MemoryFlusher@@UAGIXZ ; 1 +??1nsDirectoryService@@UAE@XZ ; 1 +?SetRegistryDllInfo@nsNativeComponentLoader@@AAEIPBDPA_J1@Z ; 1 +??1nsDirectoryIteratorImpl@@UAE@XZ ; 1 +?DestroyThreadEventQueue@nsEventQueueServiceImpl@@UAGIXZ ; 1 +?GetInt@nsRegistry@@UAGIIPBDPAH@Z ; 1 +??0MemoryFlusher@@IAE@PAVnsMemoryImpl@@@Z ; 1 +?EnumerateBackwards@nsCStringArray@@QAEHP6AHAAVnsCString@@PAX@Z1@Z ; 1 +?GetParent@nsFileSpecImpl@@UAGIPAPAVnsIFileSpec@@@Z ; 1 +?BuildFileList@xptiInterfaceInfoManager@@AAEHPAPAVnsISupportsArray@@@Z ; 1 +??1nsServiceManagerImpl@@MAE@XZ ; 1 +??1nsObserverService@@UAE@XZ ; 1 +?GetRegistryDllInfo@nsNativeComponentLoader@@AAEIPBDPA_J1@Z ; 1 +?Shutdown@nsMemoryImpl@@SAIXZ ; 1 +NS_CategoryManagerGetFactory ; 1 +?Create@nsProxyObjectManager@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1 +??_EnsDirectoryIteratorImpl@@UAEPAXI@Z ; 1 +??1nsAppFileLocationProvider@@MAE@XZ ; 1 +?GetProductDirectory@nsAppFileLocationProvider@@IAGIPAPAVnsILocalFile@@@Z ; 1 +??0?$nsCOMPtr@VnsIServiceManager@@@@QAE@ABVnsCOMPtr_helper@@@Z ; 1 +??_EnsNativeComponentLoader@@UAEPAXI@Z ; 1 +?Create@nsObserverService@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1 +??0nsCategoryManager@@AAE@XZ ; 1 +??1nsIOFileStream@@UAE@XZ ; 1 +??1nsCategoryManager@@UAE@XZ ; 1 +?InvalidateInterfaceInfos@xptiWorkingSet@@QAEXXZ ; 1 +?PlatformPrePopulateRegistry@nsComponentManagerImpl@@QAEIXZ ; 1 +?NS_InitXPCOM2@@YAIPAPAVnsIServiceManager@@PAVnsIFile@@PAVnsIDirectoryServiceProvider@@@Z ; 1 +??_EnsDirectoryIterator@@UAEPAXI@Z ; 1 +?IsValid@xptiInterfaceInfoManager@@AAEHXZ ; 1 +?Shutdown@xptiZipLoader@@SAXXZ ; 1 +?Init@nsDirectoryService@@UAGIXZ ; 1 +?Create@nsErrorService@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1 +?RegisterDeferredComponents@nsNativeComponentLoader@@UAGIHPAH@Z ; 1 +?Shutdown@nsComponentManagerImpl@@QAEIXZ ; 1 +?Shutdown@nsThread@@SAXXZ ; 1 +?Sync@nsDll@@QAEIXZ ; 1 +?Startup@nsMemoryImpl@@SAIXZ ; 1 +?Define@nsDirectoryService@@UAGIPBDPAVnsISupports@@@Z ; 1 +?SetMainThread@nsIThread@@SAIXZ ; 1 +?ShutdownSpecialSystemDirectory@@YAXXZ ; 1 +?Init@nsNativeComponentLoader@@UAGIPAVnsIComponentManager@@PAVnsISupports@@@Z ; 1 +??0nsCategoryManagerFactory@@QAE@XZ ; 1 +?RegisterErrorStringBundle@nsErrorService@@UAGIFPBD@Z ; 1 +??0nsDirectoryService@@QAE@XZ ; 1 +?RegisterFactory@nsComponentManager@@SAIABUnsID@@PBD1PAVnsIFactory@@H@Z ; 1 +?AutoRegisterImpl@nsComponentManagerImpl@@AAEIHPAVnsIFile@@@Z ; 1 +?DetermineAutoRegStrategy@xptiInterfaceInfoManager@@AAE?AW4AutoRegMode@1@PAVnsISupportsArray@@PAVxptiWorkingSet@@@Z ; 1 +??0nsAppFileLocationProvider@@QAE@XZ ; 1 +??1MemoryFlusher@@MAE@XZ ; 1 +?Create@nsLocalFile@@UAGIII@Z ; 1 +?Join@nsThread@@UAGIXZ ; 1 +??_GnsProxyObjectManager@@UAEPAXI@Z ; 1 +?LogStats@xptiInterfaceInfoManager@@AAEXXZ ; 1 +?Valid@nsFileSpec@@QBEHXZ ; 1 +?NS_InitXPCOM@@YAIPAPAVnsIServiceManager@@PAVnsIFile@@@Z ; 1 +?ShutdownGlobalServiceManager@nsServiceManager@@SAIPAPAVnsIServiceManager@@@Z ; 1 +??1xptiInterfaceInfoManager@@UAE@XZ ; 1 +??_GnsComponentManagerImpl@@UAEPAXI@Z ; 1 +?FreeInterfaceInfoManager@xptiInterfaceInfoManager@@SAXXZ ; 1 +?Create@MemoryFlusher@@SAIPAPAV1@PAVnsMemoryImpl@@@Z ; 1 +??_EnsErrorService@@UAEPAXI@Z ; 1 +??1nsProxyObjectManager@@UAE@XZ ; 1 +??0nsConsoleService@@QAE@XZ ; 1 +?AutoRegisterComponents@nsNativeComponentLoader@@UAGIHPAVnsIFile@@@Z ; 1 +?AutoRegister@nsComponentManager@@SAIHPAVnsIFile@@@Z ; 1 +?QueryInterface@nsDirectoryIteratorImpl@@UAGIABUnsID@@PAPAX@Z ; 1 +??_EMemoryFlusher@@MAEPAXI@Z ; 1 +?initialize@nsCategoryManager@@AAEIXZ ; 1 +?AutoRegisterInterfaces@xptiInterfaceInfoManager@@UAGIXZ ; 1 +PL_CreateMonitoredEventQueue ; 1 +??_GnsCategoryManager@@UAEPAXI@Z ; 1 +?Close@nsStorageStream@@UAGIXZ ; 1 +?Init@nsThreadPool@@UAGIIIIW4PRThreadPriority@@W4PRThreadScope@@@Z ; 1 +??0nsObserverService@@QAE@XZ ; 1 +?Create@nsEventQueueServiceImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1 +??0xptiInterfaceInfoManager@@AAE@XZ ; 1 +?GetDllSpec@nsDll@@QAEIPAPAVnsIFile@@@Z ; 1 +??_EnsServiceManagerImpl@@MAEPAXI@Z ; 1 +?SelfRegisterDll@nsNativeComponentLoader@@AAEIPAVnsDll@@PBDH@Z ; 1 +?UnloadAll@nsNativeComponentLoader@@UAGIH@Z ; 1 +??0?$nsCOMPtr@VnsIOutputStream@@@@QAE@ABVnsCOMPtr_helper@@@Z ; 1 +?Undefine@nsDirectoryService@@UAGIPBD@Z ; 1 +??0nsDirectoryIteratorImpl@@QAE@XZ ; 1 +??0CCaseConversionServiceInitializer@@QAE@XZ ; 1 +??1nsComponentManagerImpl@@UAE@XZ ; 1 +?RegisterComponentsInDir@nsNativeComponentLoader@@MAGIHPAVnsIFile@@@Z ; 1 +??0nsEventQueueServiceImpl@@QAE@XZ ; 1 +?CreateInstance@nsCategoryManagerFactory@@UAGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1 +??_GnsObserverService@@UAEPAXI@Z ; 1 +XPTI_FreeInterfaceInfoManager ; 1 +?Stop@MemoryFlusher@@QAEIXZ ; 1 +?CreateThreadEventQueue@nsEventQueueServiceImpl@@UAGIXZ ; 1 +??0nsServiceManagerImpl@@QAE@XZ ; 1 +??1nsNativeComponentLoader@@UAE@XZ ; 1 +??0nsThreadPool@@QAE@XZ ; 1 +?NS_ShutdownLocalFile@@YAXXZ ; 1 +??_GHandleCaseConversionShutdown3@@UAEPAXI@Z ; 1 +?Init@nsDirectoryIteratorImpl@@UAGIPAVnsIFileSpec@@H@Z ; 1 +??0nsErrorService@@QAE@XZ ; 1 +??_EnsConsoleService@@UAEPAXI@Z ; 1 +??0nsSlidingSubstring@@QAE@ABVnsAString@@@Z ; 1 +?CleanUp@nsFSStringConversion@@SAXXZ ; 1 +?Create@nsDirectoryIteratorImpl@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1 diff --git a/src/libs/xpcom18a4/xpcom/build/xpcom-tests.pkg b/src/libs/xpcom18a4/xpcom/build/xpcom-tests.pkg new file mode 100644 index 00000000..8a32b21f --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/xpcom-tests.pkg @@ -0,0 +1,47 @@ +[xpcom-tests] +#if USE_SHORT_LIBNAME +dist/bin/components/@DLLP@tdynamic@DLLS@ +dist/bin/components/@DLLP@MyServce@DLLS@ +dist/bin/components/@DLLP@xpcomsmp@DLLS@ +#else +dist/bin/components/@DLLP@testdynamic@DLLS@ +dist/bin/components/@DLLP@MyService@DLLS@ +dist/bin/components/@DLLP@xpcomsample@DLLS@ +#endif +dist/bin/components/nsSample.js +!xpt dist/bin/components/xpcomsample.xpt +dist/bin/nsTestSample@BINS@ +dist/bin/res/test.properties +dist/bin/res/samples/xpconnect-sample.html +!xpt dist/bin/components/proxytest.xpt +dist/bin/proxytests@BINS@ + +dist/bin/PrimitiveTest@BINS@ +dist/bin/SimpleTypeLib@BINS@ +dist/bin/TestInterfaceInfo@BINS@ +dist/bin/TestXPTCInvoke@BINS@ + +dist/bin/nsIFileEnumerator@BINS@ +dist/bin/nsIFileTest@BINS@ +dist/bin/TestArray@BINS@ +dist/bin/TestAtoms@BINS@ +dist/bin/TestAutoLock@BINS@ +dist/bin/TestCallTemplates@BINS@ +dist/bin/TestCOMPtr@BINS@ +dist/bin/TestCOMPtrEq@BINS@ +dist/bin/TestCRT@BINS@ +dist/bin/TestFactory@BINS@ +dist/bin/TestHashtables@BINS@ +dist/bin/TestID@BINS@ +dist/bin/TestObserverService@BINS@ +dist/bin/TestPermanentAtoms@BINS@ +dist/bin/TestPipes@BINS@ +dist/bin/TestServMgr@BINS@ +dist/bin/TestThreads@BINS@ +dist/bin/TestXPIDLString@BINS@ +dist/bin/TestDeque@BINS@ +dist/bin/TestAutoPtr@BINS@ + +#if OS_ARCH==WINNT +dist/bin/TestCOM.exe +#endif diff --git a/src/libs/xpcom18a4/xpcom/build/xpcom.pkg b/src/libs/xpcom18a4/xpcom/build/xpcom.pkg new file mode 100644 index 00000000..eab0e19d --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/xpcom.pkg @@ -0,0 +1,106 @@ +[xpcom] +dist/bin/@DLLP@xpcom@DLLS@ +!xpt dist/bin/components/xpcom_base.xpt +!xpt dist/bin/components/xpcom_components.xpt +!xpt dist/bin/components/xpcom_ds.xpt +!xpt dist/bin/components/xpcom_io.xpt +!xpt dist/bin/components/xpcom_xpti.xpt + +#if OS_ARCH==WINNT +!xpt dist/bin/components/xpcom_thread.xpt +!xpt dist/bin/components/proxyObject.xpt +#else +!xpt dist/bin/components/xpcom_threads.xpt +!xpt dist/bin/components/proxyObjInst.xpt +#endif + +[gecko-support] +dist/bin/regxpcom@BINS@ +dist/bin/xpt_dump@BINS@ +dist/bin/xpt_link@BINS@ +#if MOZ_DEBUG +#if OS_ARCH==WINNT +dist/bin/windbgdlg.exe +#endif +#endif + +# xpidl.exe is not licensed MPL, so we don't include it with applications. +# It is only included in the developer (SDK) packages. +[gecko-devel] +dist/bin/xpidl@BINS@ + +# put NSPR here, because hacking the NSPR build system is too painful +# xxxbsmedberg: this doesn't obey --with-system-nspr +[nspr] +dist/bin/@DLLP@nspr4@DLLS@ +dist/bin/@DLLP@plc4@DLLS@ +dist/bin/@DLLP@plds4@DLLS@ + +[nspr-devel] +dist/lib/@LIBP@nspr4@LIBS@ +dist/lib/@LIBP@plc4@LIBS@ +dist/lib/@LIBP@plds4@LIBS@ +dist/include/nspr/private/pprio.h +dist/include/nspr/private/pprthred.h +dist/include/nspr/private/prpriv.h +dist/include/nspr/prcpucfg.h +dist/include/nspr/obsolete/pralarm.h +dist/include/nspr/obsolete/probslet.h +dist/include/nspr/obsolete/protypes.h +dist/include/nspr/obsolete/prsem.h +dist/include/nspr/nspr.h +dist/include/nspr/pratom.h +dist/include/nspr/prbit.h +dist/include/nspr/prclist.h +dist/include/nspr/prcmon.h +dist/include/nspr/prcountr.h +dist/include/nspr/prcvar.h +dist/include/nspr/prdtoa.h +dist/include/nspr/prenv.h +dist/include/nspr/prerr.h +dist/include/nspr/prerror.h +dist/include/nspr/prinet.h +dist/include/nspr/prinit.h +dist/include/nspr/prinrval.h +dist/include/nspr/prio.h +dist/include/nspr/pripcsem.h +dist/include/nspr/prlink.h +dist/include/nspr/prlock.h +dist/include/nspr/prlog.h +dist/include/nspr/prlong.h +dist/include/nspr/prmem.h +dist/include/nspr/prmon.h +dist/include/nspr/prmwait.h +dist/include/nspr/prnetdb.h +dist/include/nspr/prolock.h +dist/include/nspr/prpdce.h +dist/include/nspr/prprf.h +dist/include/nspr/prproces.h +dist/include/nspr/prrng.h +dist/include/nspr/prrwlock.h +dist/include/nspr/prshma.h +dist/include/nspr/prshm.h +dist/include/nspr/prsystem.h +dist/include/nspr/prthread.h +dist/include/nspr/prtime.h +dist/include/nspr/prtpool.h +dist/include/nspr/prtrace.h +dist/include/nspr/prtypes.h +dist/include/nspr/prvrsion.h +dist/include/nspr/prwin16.h +dist/include/nspr/plarenas.h +dist/include/nspr/plarena.h +dist/include/nspr/plhash.h +dist/include/nspr/plbase64.h +dist/include/nspr/plerror.h +dist/include/nspr/plgetopt.h +dist/include/nspr/plresolv.h +dist/include/nspr/plstr.h + +[unpackaged-files] +!optional dist/bin/.autoreg +!optional dist/bin/components/xpti.dat +!optional dist/bin/components/compreg.dat +#if OS_ARCH==WINNT +dist/bin/rebasedlls.exe +#endif diff --git a/src/libs/xpcom18a4/xpcom/build/xpcom_alpha.def b/src/libs/xpcom18a4/xpcom/build/xpcom_alpha.def new file mode 100644 index 00000000..966f2ea4 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/build/xpcom_alpha.def @@ -0,0 +1,252 @@ +LIBRARY xpcom +DESCRIPTION "xpcom library" + +EXPORTS + ?Stub3@nsXPTCStubBase@@UAAIXZ + ?Stub4@nsXPTCStubBase@@UAAIXZ + ?Stub5@nsXPTCStubBase@@UAAIXZ + ?Stub6@nsXPTCStubBase@@UAAIXZ + ?Stub7@nsXPTCStubBase@@UAAIXZ + ?Stub8@nsXPTCStubBase@@UAAIXZ + ?Stub9@nsXPTCStubBase@@UAAIXZ + ?Stub10@nsXPTCStubBase@@UAAIXZ + ?Stub11@nsXPTCStubBase@@UAAIXZ + ?Stub12@nsXPTCStubBase@@UAAIXZ + ?Stub13@nsXPTCStubBase@@UAAIXZ + ?Stub14@nsXPTCStubBase@@UAAIXZ + ?Stub15@nsXPTCStubBase@@UAAIXZ + ?Stub16@nsXPTCStubBase@@UAAIXZ + ?Stub17@nsXPTCStubBase@@UAAIXZ + ?Stub18@nsXPTCStubBase@@UAAIXZ + ?Stub19@nsXPTCStubBase@@UAAIXZ + ?Stub20@nsXPTCStubBase@@UAAIXZ + ?Stub21@nsXPTCStubBase@@UAAIXZ + ?Stub22@nsXPTCStubBase@@UAAIXZ + ?Stub23@nsXPTCStubBase@@UAAIXZ + ?Stub24@nsXPTCStubBase@@UAAIXZ + ?Stub25@nsXPTCStubBase@@UAAIXZ + ?Stub26@nsXPTCStubBase@@UAAIXZ + ?Stub27@nsXPTCStubBase@@UAAIXZ + ?Stub28@nsXPTCStubBase@@UAAIXZ + ?Stub29@nsXPTCStubBase@@UAAIXZ + ?Stub30@nsXPTCStubBase@@UAAIXZ + ?Stub31@nsXPTCStubBase@@UAAIXZ + ?Stub32@nsXPTCStubBase@@UAAIXZ + ?Stub33@nsXPTCStubBase@@UAAIXZ + ?Stub34@nsXPTCStubBase@@UAAIXZ + ?Stub35@nsXPTCStubBase@@UAAIXZ + ?Stub36@nsXPTCStubBase@@UAAIXZ + ?Stub37@nsXPTCStubBase@@UAAIXZ + ?Stub38@nsXPTCStubBase@@UAAIXZ + ?Stub39@nsXPTCStubBase@@UAAIXZ + ?Stub40@nsXPTCStubBase@@UAAIXZ + ?Stub41@nsXPTCStubBase@@UAAIXZ + ?Stub42@nsXPTCStubBase@@UAAIXZ + ?Stub43@nsXPTCStubBase@@UAAIXZ + ?Stub44@nsXPTCStubBase@@UAAIXZ + ?Stub45@nsXPTCStubBase@@UAAIXZ + ?Stub46@nsXPTCStubBase@@UAAIXZ + ?Stub47@nsXPTCStubBase@@UAAIXZ + ?Stub48@nsXPTCStubBase@@UAAIXZ + ?Stub49@nsXPTCStubBase@@UAAIXZ + ?Stub50@nsXPTCStubBase@@UAAIXZ + ?Stub51@nsXPTCStubBase@@UAAIXZ + ?Stub52@nsXPTCStubBase@@UAAIXZ + ?Stub53@nsXPTCStubBase@@UAAIXZ + ?Stub54@nsXPTCStubBase@@UAAIXZ + ?Stub55@nsXPTCStubBase@@UAAIXZ + ?Stub56@nsXPTCStubBase@@UAAIXZ + ?Stub57@nsXPTCStubBase@@UAAIXZ + ?Stub58@nsXPTCStubBase@@UAAIXZ + ?Stub59@nsXPTCStubBase@@UAAIXZ + ?Stub60@nsXPTCStubBase@@UAAIXZ + ?Stub61@nsXPTCStubBase@@UAAIXZ + ?Stub62@nsXPTCStubBase@@UAAIXZ + ?Stub63@nsXPTCStubBase@@UAAIXZ + ?Stub64@nsXPTCStubBase@@UAAIXZ + ?Stub65@nsXPTCStubBase@@UAAIXZ + ?Stub66@nsXPTCStubBase@@UAAIXZ + ?Stub67@nsXPTCStubBase@@UAAIXZ + ?Stub68@nsXPTCStubBase@@UAAIXZ + ?Stub69@nsXPTCStubBase@@UAAIXZ + ?Stub70@nsXPTCStubBase@@UAAIXZ + ?Stub71@nsXPTCStubBase@@UAAIXZ + ?Stub72@nsXPTCStubBase@@UAAIXZ + ?Stub73@nsXPTCStubBase@@UAAIXZ + ?Stub74@nsXPTCStubBase@@UAAIXZ + ?Stub75@nsXPTCStubBase@@UAAIXZ + ?Stub76@nsXPTCStubBase@@UAAIXZ + ?Stub77@nsXPTCStubBase@@UAAIXZ + ?Stub78@nsXPTCStubBase@@UAAIXZ + ?Stub79@nsXPTCStubBase@@UAAIXZ + ?Stub80@nsXPTCStubBase@@UAAIXZ + ?Stub81@nsXPTCStubBase@@UAAIXZ + ?Stub82@nsXPTCStubBase@@UAAIXZ + ?Stub83@nsXPTCStubBase@@UAAIXZ + ?Stub84@nsXPTCStubBase@@UAAIXZ + ?Stub85@nsXPTCStubBase@@UAAIXZ + ?Stub86@nsXPTCStubBase@@UAAIXZ + ?Stub87@nsXPTCStubBase@@UAAIXZ + ?Stub88@nsXPTCStubBase@@UAAIXZ + ?Stub89@nsXPTCStubBase@@UAAIXZ + ?Stub90@nsXPTCStubBase@@UAAIXZ + ?Stub91@nsXPTCStubBase@@UAAIXZ + ?Stub92@nsXPTCStubBase@@UAAIXZ + ?Stub93@nsXPTCStubBase@@UAAIXZ + ?Stub94@nsXPTCStubBase@@UAAIXZ + ?Stub95@nsXPTCStubBase@@UAAIXZ + ?Stub96@nsXPTCStubBase@@UAAIXZ + ?Stub97@nsXPTCStubBase@@UAAIXZ + ?Stub98@nsXPTCStubBase@@UAAIXZ + ?Stub99@nsXPTCStubBase@@UAAIXZ + ?Stub100@nsXPTCStubBase@@UAAIXZ + ?Stub101@nsXPTCStubBase@@UAAIXZ + ?Stub102@nsXPTCStubBase@@UAAIXZ + ?Stub103@nsXPTCStubBase@@UAAIXZ + ?Stub104@nsXPTCStubBase@@UAAIXZ + ?Stub105@nsXPTCStubBase@@UAAIXZ + ?Stub106@nsXPTCStubBase@@UAAIXZ + ?Stub107@nsXPTCStubBase@@UAAIXZ + ?Stub108@nsXPTCStubBase@@UAAIXZ + ?Stub109@nsXPTCStubBase@@UAAIXZ + ?Stub110@nsXPTCStubBase@@UAAIXZ + ?Stub111@nsXPTCStubBase@@UAAIXZ + ?Stub112@nsXPTCStubBase@@UAAIXZ + ?Stub113@nsXPTCStubBase@@UAAIXZ + ?Stub114@nsXPTCStubBase@@UAAIXZ + ?Stub115@nsXPTCStubBase@@UAAIXZ + ?Stub116@nsXPTCStubBase@@UAAIXZ + ?Stub117@nsXPTCStubBase@@UAAIXZ + ?Stub118@nsXPTCStubBase@@UAAIXZ + ?Stub119@nsXPTCStubBase@@UAAIXZ + ?Stub120@nsXPTCStubBase@@UAAIXZ + ?Stub121@nsXPTCStubBase@@UAAIXZ + ?Stub122@nsXPTCStubBase@@UAAIXZ + ?Stub123@nsXPTCStubBase@@UAAIXZ + ?Stub124@nsXPTCStubBase@@UAAIXZ + ?Stub125@nsXPTCStubBase@@UAAIXZ + ?Stub126@nsXPTCStubBase@@UAAIXZ + ?Stub127@nsXPTCStubBase@@UAAIXZ + ?Stub128@nsXPTCStubBase@@UAAIXZ + ?Stub129@nsXPTCStubBase@@UAAIXZ + ?Stub130@nsXPTCStubBase@@UAAIXZ + ?Stub131@nsXPTCStubBase@@UAAIXZ + ?Stub132@nsXPTCStubBase@@UAAIXZ + ?Stub133@nsXPTCStubBase@@UAAIXZ + ?Stub134@nsXPTCStubBase@@UAAIXZ + ?Stub135@nsXPTCStubBase@@UAAIXZ + ?Stub136@nsXPTCStubBase@@UAAIXZ + ?Stub137@nsXPTCStubBase@@UAAIXZ + ?Stub138@nsXPTCStubBase@@UAAIXZ + ?Stub139@nsXPTCStubBase@@UAAIXZ + ?Stub140@nsXPTCStubBase@@UAAIXZ + ?Stub141@nsXPTCStubBase@@UAAIXZ + ?Stub142@nsXPTCStubBase@@UAAIXZ + ?Stub143@nsXPTCStubBase@@UAAIXZ + ?Stub144@nsXPTCStubBase@@UAAIXZ + ?Stub145@nsXPTCStubBase@@UAAIXZ + ?Stub146@nsXPTCStubBase@@UAAIXZ + ?Stub147@nsXPTCStubBase@@UAAIXZ + ?Stub148@nsXPTCStubBase@@UAAIXZ + ?Stub149@nsXPTCStubBase@@UAAIXZ + ?Stub150@nsXPTCStubBase@@UAAIXZ + ?Stub151@nsXPTCStubBase@@UAAIXZ + ?Stub152@nsXPTCStubBase@@UAAIXZ + ?Stub153@nsXPTCStubBase@@UAAIXZ + ?Stub154@nsXPTCStubBase@@UAAIXZ + ?Stub155@nsXPTCStubBase@@UAAIXZ + ?Stub156@nsXPTCStubBase@@UAAIXZ + ?Stub157@nsXPTCStubBase@@UAAIXZ + ?Stub158@nsXPTCStubBase@@UAAIXZ + ?Stub159@nsXPTCStubBase@@UAAIXZ + ?Stub160@nsXPTCStubBase@@UAAIXZ + ?Stub161@nsXPTCStubBase@@UAAIXZ + ?Stub162@nsXPTCStubBase@@UAAIXZ + ?Stub163@nsXPTCStubBase@@UAAIXZ + ?Stub164@nsXPTCStubBase@@UAAIXZ + ?Stub165@nsXPTCStubBase@@UAAIXZ + ?Stub166@nsXPTCStubBase@@UAAIXZ + ?Stub167@nsXPTCStubBase@@UAAIXZ + ?Stub168@nsXPTCStubBase@@UAAIXZ + ?Stub169@nsXPTCStubBase@@UAAIXZ + ?Stub170@nsXPTCStubBase@@UAAIXZ + ?Stub171@nsXPTCStubBase@@UAAIXZ + ?Stub172@nsXPTCStubBase@@UAAIXZ + ?Stub173@nsXPTCStubBase@@UAAIXZ + ?Stub174@nsXPTCStubBase@@UAAIXZ + ?Stub175@nsXPTCStubBase@@UAAIXZ + ?Stub176@nsXPTCStubBase@@UAAIXZ + ?Stub177@nsXPTCStubBase@@UAAIXZ + ?Stub178@nsXPTCStubBase@@UAAIXZ + ?Stub179@nsXPTCStubBase@@UAAIXZ + ?Stub180@nsXPTCStubBase@@UAAIXZ + ?Stub181@nsXPTCStubBase@@UAAIXZ + ?Stub182@nsXPTCStubBase@@UAAIXZ + ?Stub183@nsXPTCStubBase@@UAAIXZ + ?Stub184@nsXPTCStubBase@@UAAIXZ + ?Stub185@nsXPTCStubBase@@UAAIXZ + ?Stub186@nsXPTCStubBase@@UAAIXZ + ?Stub187@nsXPTCStubBase@@UAAIXZ + ?Stub188@nsXPTCStubBase@@UAAIXZ + ?Stub189@nsXPTCStubBase@@UAAIXZ + ?Stub190@nsXPTCStubBase@@UAAIXZ + ?Stub191@nsXPTCStubBase@@UAAIXZ + ?Stub192@nsXPTCStubBase@@UAAIXZ + ?Stub193@nsXPTCStubBase@@UAAIXZ + ?Stub194@nsXPTCStubBase@@UAAIXZ + ?Stub195@nsXPTCStubBase@@UAAIXZ + ?Stub196@nsXPTCStubBase@@UAAIXZ + ?Stub197@nsXPTCStubBase@@UAAIXZ + ?Stub198@nsXPTCStubBase@@UAAIXZ + ?Stub199@nsXPTCStubBase@@UAAIXZ + ?Stub200@nsXPTCStubBase@@UAAIXZ + ?Stub201@nsXPTCStubBase@@UAAIXZ + ?Stub202@nsXPTCStubBase@@UAAIXZ + ?Stub203@nsXPTCStubBase@@UAAIXZ + ?Stub204@nsXPTCStubBase@@UAAIXZ + ?Stub205@nsXPTCStubBase@@UAAIXZ + ?Stub206@nsXPTCStubBase@@UAAIXZ + ?Stub207@nsXPTCStubBase@@UAAIXZ + ?Stub208@nsXPTCStubBase@@UAAIXZ + ?Stub209@nsXPTCStubBase@@UAAIXZ + ?Stub210@nsXPTCStubBase@@UAAIXZ + ?Stub211@nsXPTCStubBase@@UAAIXZ + ?Stub212@nsXPTCStubBase@@UAAIXZ + ?Stub213@nsXPTCStubBase@@UAAIXZ + ?Stub214@nsXPTCStubBase@@UAAIXZ + ?Stub215@nsXPTCStubBase@@UAAIXZ + ?Stub216@nsXPTCStubBase@@UAAIXZ + ?Stub217@nsXPTCStubBase@@UAAIXZ + ?Stub218@nsXPTCStubBase@@UAAIXZ + ?Stub219@nsXPTCStubBase@@UAAIXZ + ?Stub220@nsXPTCStubBase@@UAAIXZ + ?Stub221@nsXPTCStubBase@@UAAIXZ + ?Stub222@nsXPTCStubBase@@UAAIXZ + ?Stub223@nsXPTCStubBase@@UAAIXZ + ?Stub224@nsXPTCStubBase@@UAAIXZ + ?Stub225@nsXPTCStubBase@@UAAIXZ + ?Stub226@nsXPTCStubBase@@UAAIXZ + ?Stub227@nsXPTCStubBase@@UAAIXZ + ?Stub228@nsXPTCStubBase@@UAAIXZ + ?Stub229@nsXPTCStubBase@@UAAIXZ + ?Stub230@nsXPTCStubBase@@UAAIXZ + ?Stub231@nsXPTCStubBase@@UAAIXZ + ?Stub232@nsXPTCStubBase@@UAAIXZ + ?Stub233@nsXPTCStubBase@@UAAIXZ + ?Stub234@nsXPTCStubBase@@UAAIXZ + ?Stub235@nsXPTCStubBase@@UAAIXZ + ?Stub236@nsXPTCStubBase@@UAAIXZ + ?Stub237@nsXPTCStubBase@@UAAIXZ + ?Stub238@nsXPTCStubBase@@UAAIXZ + ?Stub239@nsXPTCStubBase@@UAAIXZ + ?Stub240@nsXPTCStubBase@@UAAIXZ + ?Stub241@nsXPTCStubBase@@UAAIXZ + ?Stub242@nsXPTCStubBase@@UAAIXZ + ?Stub243@nsXPTCStubBase@@UAAIXZ + ?Stub244@nsXPTCStubBase@@UAAIXZ + ?Stub245@nsXPTCStubBase@@UAAIXZ + ?Stub246@nsXPTCStubBase@@UAAIXZ + ?Stub247@nsXPTCStubBase@@UAAIXZ + ?Stub248@nsXPTCStubBase@@UAAIXZ + ?Stub249@nsXPTCStubBase@@UAAIXZ + |