From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26970 invoked by alias); 6 Feb 2002 03:56:04 -0000 Mailing-List: contact gcc-prs-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Archive: List-Post: List-Help: Sender: gcc-prs-owner@gcc.gnu.org Received: (qmail 26913 invoked by uid 71); 6 Feb 2002 03:56:02 -0000 Resent-Date: 6 Feb 2002 03:56:02 -0000 Resent-Message-ID: <20020206035602.26911.qmail@sources.redhat.com> Resent-From: gcc-gnats@gcc.gnu.org (GNATS Filer) Resent-To: nobody@gcc.gnu.org Resent-Cc: gcc-prs@gcc.gnu.org, gcc-bugs@gcc.gnu.org Resent-Reply-To: gcc-gnats@gcc.gnu.org, Mathew Yeates Received:(qmail 5023 invoked from network); 6 Feb 2002 03:46:03 -0000 Received: from unknown (HELO forte.jpl.nasa.gov) (137.78.28.101) by sources.redhat.com with SMTP; 6 Feb 2002 03:46:03 -0000 Received: (from mathew@localhost) by forte.jpl.nasa.gov (SGI-8.9.3/8.9.3) id TAA85899; Tue, 5 Feb 2002 19:46:02 -0800 (PST) Message-Id:<200202060346.TAA85899@forte.jpl.nasa.gov> Date: Tue, 05 Feb 2002 19:56:00 -0000 From: Mathew Yeates To: gcc-gnats@gcc.gnu.org X-Send-Pr-Version:3.113 Subject: c++/5602: g++3.0.3 internal compiler error emit_move_insn_1, at expr.c:2975 X-SW-Source: 2002-02/txt/msg00127.txt.bz2 List-Id: >Number: 5602 >Category: c++ >Synopsis: g++3.0.3 internal compiler error emit_move_insn_1, at expr.c:2975 >Confidential: no >Severity: critical >Priority: medium >Responsible: unassigned >State: open >Class: ice-on-legal-code >Submitter-Id: net >Arrival-Date: Tue Feb 05 19:56:02 PST 2002 >Closed-Date: >Last-Modified: >Originator: Mathew Yeates >Release: 3.0.3 >Organization: >Environment: System: IRIX64 forte 6.5 07201611 IP27 host: mips-sgi-irix6.5 build: mips-sgi-irix6.5 target: mips-sgi-irix6.5 configured with: ../src/gcc-3.0.3/configure --prefix=/hsgi/mathew/root >Description: g++ failed while compiling code for mozilla >How-To-Repeat: Preprocessor output: typedef int ptrdiff_t; typedef unsigned int size_t; extern "C" { typedef unsigned char PRUint8; typedef signed char PRInt8; typedef unsigned short PRUint16; typedef short PRInt16; typedef unsigned int PRUint32; typedef int PRInt32; typedef long long PRInt64; typedef unsigned long long PRUint64; typedef int PRIntn; typedef unsigned int PRUintn; typedef double PRFloat64; typedef size_t PRSize; typedef PRInt32 PROffset32; typedef PRInt64 PROffset64; typedef ptrdiff_t PRPtrdiff; typedef unsigned long PRUptrdiff; typedef PRIntn PRBool; typedef PRUint8 PRPackedBool; typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus; typedef long PRWord; typedef unsigned long PRUword; typedef PRUintn uintn; typedef PRIntn intn; #ident "$Revision: 3.141 $" #ident "$Id: standards.h,v 1.19 1997/12/15 21:30:25 jph Exp $" extern "C" { #ident "$Revision: 1.11 $" typedef int __int32_t; typedef unsigned __uint32_t; typedef long long __int64_t; typedef unsigned long long __uint64_t; typedef __int32_t __psint_t; typedef __uint32_t __psunsigned_t; typedef __int32_t __scint_t; typedef __uint32_t __scunsigned_t; } typedef unsigned char uchar_t; typedef unsigned short ushort_t; typedef unsigned int uint_t; typedef unsigned long ulong_t; extern "C" { typedef unsigned int pthread_t; typedef struct { long __D[5]; } pthread_attr_t; typedef struct { long __D[8]; } pthread_mutex_t; typedef struct { long __D[2]; } pthread_mutexattr_t; typedef struct { long __D[8]; } pthread_cond_t; typedef struct { long __D[2]; } pthread_condattr_t; typedef struct { long __D[16]; } pthread_rwlock_t; typedef struct { long __D[4]; } pthread_rwlockattr_t; typedef int pthread_key_t; typedef int pthread_once_t; } typedef char * addr_t; typedef char * caddr_t; typedef __int64_t daddr_t; typedef long pgno_t; typedef __uint32_t pfn_t; typedef short cnt_t; typedef unsigned long basictime_t; typedef __int64_t micro_t; typedef __int32_t pgcnt_t; typedef enum { B_FALSE, B_TRUE } boolean_t; typedef long id_t; typedef ulong_t major_t; typedef ulong_t minor_t; typedef ushort_t o_mode_t; typedef short o_dev_t; typedef ushort_t o_uid_t; typedef o_uid_t o_gid_t; typedef short o_nlink_t; typedef short o_pid_t; typedef __uint32_t o_ino_t; typedef unsigned long mode_t; typedef unsigned long dev_t; typedef long uid_t; typedef long gid_t; typedef unsigned long nlink_t; typedef long pid_t; typedef int tid_t; typedef dev_t vertex_hdl_t; typedef __uint64_t ino_t; typedef __uint64_t ino64_t; typedef __int64_t off_t; typedef __int64_t off64_t; typedef __scint_t __scoff_t; typedef __scoff_t scoff_t; typedef __int64_t blkcnt64_t; typedef __uint64_t fsblkcnt64_t; typedef __uint64_t fsfilcnt64_t; typedef __int64_t blkcnt_t; typedef __uint64_t fsblkcnt_t; typedef __uint64_t fsfilcnt_t; typedef long swblk_t; typedef unsigned long paddr_t; typedef unsigned long iopaddr_t; typedef int key_t; typedef unsigned char use_t; typedef long sysid_t; typedef short index_t; typedef signed short nasid_t; typedef signed short cnodeid_t; typedef signed char partid_t; typedef signed short moduleid_t; typedef signed short cmoduleid_t; typedef uchar_t clusterid_t; typedef unsigned int lock_t; typedef signed short cpuid_t; typedef unsigned char pri_t; typedef __uint64_t accum_t; typedef __int64_t prid_t; typedef __int64_t ash_t; typedef short cell_t; typedef int credid_t; typedef __int64_t jid_t; typedef int ssize_t; typedef long time_t; typedef long clock_t; typedef int clockid_t; typedef int timer_t; typedef unsigned int useconds_t; typedef __scunsigned_t bitnum_t; typedef __scunsigned_t bitlen_t; typedef int processorid_t; typedef int toid_t; typedef long *qaddr_t; typedef __uint32_t inst_t; typedef __uint64_t machreg_t; typedef __uint64_t fpreg_t; typedef signed char int8_t; typedef unsigned char uint8_t; typedef signed short int16_t; typedef unsigned short uint16_t; typedef signed int int32_t; typedef unsigned int uint32_t; typedef __int64_t int64_t; typedef __uint64_t uint64_t; typedef __int64_t intmax_t; typedef __uint64_t uintmax_t; typedef signed long int intptr_t; typedef unsigned long int uintptr_t; typedef unsigned char u_int8_t; typedef unsigned short u_int16_t; typedef __uint32_t u_int32_t; typedef long hostid_t; #ident "$Revision: 1.2 $" typedef struct { int r[1]; } * physadr; typedef unsigned char unchar; typedef unsigned char u_char; typedef unsigned short ushort; typedef unsigned short u_short; typedef unsigned int uint; typedef unsigned int u_int; typedef unsigned long ulong; typedef unsigned long u_long; typedef struct _quad { long val[2]; } quad; #ident "$Revision: 1.17 $" extern "C" { typedef long fd_mask_t; typedef unsigned long ufd_mask_t; typedef struct fd_set { fd_mask_t fds_bits[(((1024)+(((int)(sizeof(fd_mask_t) * 8))-1))/((int)(sizeof(fd_mask_t) * 8)))]; } fd_set; extern "C" { #ident "$Revision: 1.41 $" extern void *memcpy(void *, const void *, size_t); extern void *memmove(void *, const void *, size_t); extern char *strcpy(char *, const char *); extern char *strncpy(char *, const char *, size_t); extern char *strcat(char *, const char *); extern char *strncat(char *, const char *, size_t); extern void *memccpy(void *, const void *, int, size_t); extern int memcmp(const void *, const void *, size_t); extern int strcmp(const char *, const char *); extern int strcoll(const char *, const char *); extern int strncmp(const char *, const char *, size_t); extern size_t strxfrm(char *, const char *, size_t); extern void *memchr(const void *, int, size_t); extern char *strchr(const char *, int); extern size_t strcspn(const char *, const char *); #pragma int_to_unsigned strcspn extern char *strpbrk(const char *, const char *); extern char *strrchr(const char *, int); extern size_t strspn(const char *, const char *); #pragma int_to_unsigned strspn extern char *strstr(const char *, const char *); extern char *strtok(char *, const char *); extern void *memset(void *, int, size_t); extern char *strerror(int); extern size_t strlen(const char *); #pragma int_to_unsigned strlen extern int ffs(int); extern int strcasecmp(const char *, const char *); extern int strncasecmp(const char *, const char *, size_t); extern char *strdup(const char *); extern char *strtok_r(char *, const char *, char **); } typedef long fd_mask; } typedef __uint64_t k_sigset_t; typedef PRUint64 uint64; typedef PRUint32 uint32; typedef PRUint16 uint16; typedef PRUint8 uint8; typedef PRInt64 int64; typedef PRInt32 int32; typedef PRInt16 int16; typedef PRInt8 int8; typedef PRFloat64 float64; typedef PRUptrdiff uptrdiff_t; typedef PRUword uprword_t; typedef PRWord prword_t; } typedef PRUint32 nsresult; typedef PRUint16 PRUnichar; extern nsresult NS_ErrorAccordingToNSPR(); class nsDebug { public: static void AbortIfFalse(const char* aStr, const char* aExpr, const char* aFile, PRIntn aLine); static PRBool WarnIfFalse(const char* aStr, const char* aExpr, const char* aFile, PRIntn aLine); static void SetWarningMessageBoxEnable(PRBool aOnOff); static PRBool GetWarningMessageBoxEnable(void); static void Abort(const char* aFile, PRIntn aLine); static void Break(const char* aFile, PRIntn aLine); static void PreCondition(const char* aStr, const char* aExpr, const char* aFile, PRIntn aLine); static void PostCondition(const char* aStr, const char* aExpr, const char* aFile, PRIntn aLine); static void Assertion(const char* aStr, const char* aExpr, const char* aFile, PRIntn aLine); static void NotYetImplemented(const char* aMessage, const char* aFile, PRIntn aLine); static void NotReached(const char* aMessage, const char* aFile, PRIntn aLine); static void Error(const char* aMessage, const char* aFile, PRIntn aLine); static void Warning(const char* aMessage, const char* aFile, PRIntn aLine); }; extern "C" { extern PRInt64 LL_MaxInt(void); extern PRInt64 LL_MinInt(void); extern PRInt64 LL_Zero(void); } extern "C" { typedef PRInt64 PRTime; typedef struct PRTimeParameters { PRInt32 tp_gmt_offset; PRInt32 tp_dst_offset; } PRTimeParameters; typedef struct PRExplodedTime { PRInt32 tm_usec; PRInt32 tm_sec; PRInt32 tm_min; PRInt32 tm_hour; PRInt32 tm_mday; PRInt32 tm_month; PRInt16 tm_year; PRInt8 tm_wday; PRInt16 tm_yday; PRTimeParameters tm_params; } PRExplodedTime; typedef PRTimeParameters ( *PRTimeParamFn)(const PRExplodedTime *gmt); extern PRTime PR_Now(void); extern void PR_ExplodeTime( PRTime usecs, PRTimeParamFn params, PRExplodedTime *exploded); extern PRTime PR_ImplodeTime(const PRExplodedTime *exploded); extern void PR_NormalizeTime( PRExplodedTime *exploded, PRTimeParamFn params); extern PRTimeParameters PR_LocalTimeParameters(const PRExplodedTime *gmt); extern PRTimeParameters PR_GMTParameters(const PRExplodedTime *gmt); extern PRTimeParameters PR_USPacificTimeParameters(const PRExplodedTime *gmt); extern PRStatus PR_ParseTimeString ( const char *string, PRBool default_to_gmt, PRTime *result); extern PRUint32 PR_FormatTime(char *buf, int buflen, const char *fmt, const PRExplodedTime *tm); extern PRUint32 PR_FormatTimeUSEnglish( char* buf, PRUint32 bufSize, const char* format, const PRExplodedTime* tm ); } struct nsID { PRUint32 m0; PRUint16 m1; PRUint16 m2; PRUint8 m3[8]; inline PRBool Equals(const nsID& other) const { return (PRBool) ((((PRUint32*) &m0)[0] == ((PRUint32*) &other.m0)[0]) && (((PRUint32*) &m0)[1] == ((PRUint32*) &other.m0)[1]) && (((PRUint32*) &m0)[2] == ((PRUint32*) &other.m0)[2]) && (((PRUint32*) &m0)[3] == ((PRUint32*) &other.m0)[3])); } PRBool Parse(const char *aIDStr); char* ToString() const; }; typedef nsID nsCID; typedef nsID nsIID; typedef PRUint32 nsrefcnt; class nsISupports { public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr) = 0; virtual nsrefcnt AddRef(void) = 0; virtual nsrefcnt Release(void) = 0; }; extern "C" { typedef struct PRLock PRLock; extern PRLock* PR_NewLock(void); extern void PR_DestroyLock(PRLock *lock); extern void PR_Lock(PRLock *lock); extern PRStatus PR_Unlock(PRLock *lock); } extern "C" { extern PRInt32 PR_AtomicIncrement(PRInt32 *val); extern PRInt32 PR_AtomicDecrement(PRInt32 *val); extern PRInt32 PR_AtomicSet(PRInt32 *val, PRInt32 newval); extern PRInt32 PR_AtomicAdd(PRInt32 *ptr, PRInt32 val); typedef struct PRStackElemStr PRStackElem; struct PRStackElemStr { PRStackElem *prstk_elem_next; }; typedef struct PRStackStr PRStack; extern PRStack * PR_CreateStack(const char *stack_name); extern void PR_StackPush(PRStack *stack, PRStackElem *stack_elem); extern PRStackElem * PR_StackPop(PRStack *stack); extern PRStatus PR_DestroyStack(PRStack *stack); } typedef __builtin_va_list __gnuc_va_list; extern "C" { #ident "$Revision: 1.75 $" typedef __int64_t fpos_t; typedef __int64_t fpos64_t; typedef char *__not_va_list__; typedef struct __file_s { int _cnt; unsigned char *_ptr; unsigned char *_base; unsigned char _flag; unsigned char _o_file; unsigned short _file; } FILE; extern FILE __iob[100]; extern FILE *_lastbuf; extern unsigned char *_bufendtab[]; extern unsigned char _sibuf[], _sobuf[]; extern int remove(const char *); extern int rename(const char *, const char *); extern FILE *tmpfile(void); extern char *tmpnam(char *); extern int fclose(FILE *); extern int fflush(FILE *); extern FILE *fopen(const char *, const char *); extern FILE *freopen(const char *, const char *, FILE *); extern void setbuf(FILE *, char *); extern int setvbuf(FILE *, char *, int, size_t); extern int fprintf(FILE *, const char *, ...); extern int fscanf(FILE *, const char *, ...); extern int printf(const char *, ...); extern int scanf(const char *, ...); extern int snprintf(char *, ssize_t, const char *, ...); extern int sprintf(char *, const char *, ...); extern int sscanf(const char *, const char *, ...); extern int vfprintf(FILE *, const char *, __gnuc_va_list); extern int vprintf(const char *, __gnuc_va_list); extern int vsnprintf(char *, ssize_t, const char *, __gnuc_va_list); extern int vsprintf(char *, const char *, __gnuc_va_list); extern int fgetc(FILE *); extern char *fgets(char *, int, FILE *); extern int fputc(int, FILE *); extern int fputs(const char *, FILE *); extern int getc(FILE *); extern int getchar(void); extern char *gets(char *); extern int putc(int, FILE *); extern int putchar(int); extern int puts(const char *); extern int ungetc(int, FILE *); extern size_t fread(void *, size_t, size_t, FILE *); #pragma int_to_unsigned fread extern size_t fwrite(const void *, size_t, size_t, FILE *); #pragma int_to_unsigned fwrite extern int fgetpos(FILE *, fpos_t *); extern int fseek(FILE *, long, int); extern int fsetpos(FILE *, const fpos_t *); extern long ftell(FILE *); extern void rewind(FILE *); extern void clearerr(FILE *); extern int feof(FILE *); extern int ferror(FILE *); extern void perror(const char *); extern int __filbuf(FILE *); extern int __flsbuf(int, FILE *); extern FILE *fdopen(int, const char *); extern int fileno(FILE *); extern void flockfile(FILE *); extern int ftrylockfile(FILE *); extern void funlockfile(FILE *); extern int getc_unlocked(FILE *); extern int putc_unlocked(int, FILE *); extern int getchar_unlocked(void); extern int putchar_unlocked(int); extern FILE *popen(const char *, const char *); extern int pclose(FILE *); #ident "$Revision: 1.11 $" extern "C" { extern int getopt(int, char *const *, const char *); extern char *optarg; extern int opterr; extern int optind; extern int optopt; extern int getsubopt(char **, char *const *, char **); extern void getoptreset(void); } extern char *ctermid(char *); extern char *cuserid(char *); extern char *tempnam(const char *, const char *); extern int getw(FILE *); extern int putw(int, FILE *); extern char *mktemp(char *); extern int mkstemp(char *); extern int setbuffer(FILE *, char *, int); extern int setlinebuf(FILE *); extern int system(const char *); extern off_t ftello(FILE *); extern int fseeko(FILE *, off_t, int); extern int fgetpos64(FILE *, fpos64_t *); extern FILE *fopen64(const char *, const char *); extern FILE *freopen64(const char *, const char *, FILE *); extern int fseek64(FILE *, __int64_t, int); extern int fseeko64(FILE *, off64_t, int); extern int fsetpos64(FILE *, const fpos64_t *); extern __int64_t ftell64(FILE *); extern off64_t ftello64(FILE *); extern FILE *tmpfile64(void); extern int __semputc(int, FILE *); extern int __semgetc(FILE *); extern int __us_rsthread_stdio; extern char *ctermid_r(char *); } class nsISupports; struct nsTraceRefcntStats { nsrefcnt mAddRefs; nsrefcnt mReleases; nsrefcnt mCreates; nsrefcnt mDestroys; double mRefsOutstandingTotal; double mRefsOutstandingSquared; double mObjsOutstandingTotal; double mObjsOutstandingSquared; }; typedef PRBool ( *nsTraceRefcntStatFunc) (const char* aTypeName, PRUint32 aInstanceSize, nsTraceRefcntStats* aCurrentStats, nsTraceRefcntStats* aPrevStats, void *aClosure); class nsTraceRefcnt { public: static void Startup(); static void Shutdown(); static void LogAddRef(void* aPtr, nsrefcnt aNewRefCnt, const char* aTypeName, PRUint32 aInstanceSize); static void LogRelease(void* aPtr, nsrefcnt aNewRefCnt, const char* aTypeName); static void LogNewXPCOM(void* aPtr, const char* aTypeName, PRUint32 aInstanceSize, const char* aFile, int aLine); static void LogDeleteXPCOM(void* aPtr, const char* aFile, int aLine); static nsrefcnt LogAddRefCall(void* aPtr, nsrefcnt aNewRefcnt, const char* aFile, int aLine); static nsrefcnt LogReleaseCall(void* aPtr, nsrefcnt aNewRefcnt, const char* aFile, int aLine); static void LogCtor(void* aPtr, const char* aTypeName, PRUint32 aInstanceSize); static void LogDtor(void* aPtr, const char* aTypeName, PRUint32 aInstanceSize); static void LogAddCOMPtr(void *aCOMPtr, nsISupports *aObject); static void LogReleaseCOMPtr(void *aCOMPtr, nsISupports *aObject); enum StatisticsType { ALL_STATS, NEW_STATS }; static nsresult DumpStatistics(StatisticsType type = ALL_STATS, FILE* out = 0); static void ResetStatistics(void); static void GatherStatistics(nsTraceRefcntStatFunc aFunc, void* aClosure); static void LoadLibrarySymbols(const char* aLibraryName, void* aLibrayHandle); static void DemangleSymbol(const char * aSymbol, char * aBuffer, int aBufLen); static void WalkTheStack(FILE* aStream); static void SetPrefServiceAvailability(PRBool avail); static void SetActivityIsLegal(PRBool aLegal); }; extern "C" void NS_MeanAndStdDev(double n, double sumOfValues, double sumOfSquaredValues, double *meanResult, double *stdDevResult); extern "C" void* NS_CurrentThread(void); extern "C" void NS_CheckThreadSafe(void* owningThread, const char* msg); class nsIProgrammingLanguage : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xea604e90, 0x40ba, 0x11d5, { 0x90, 0xbb, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} enum { UNKNOWN = 0U }; enum { CPLUSPLUS = 1U }; enum { JAVASCRIPT = 2U }; enum { PYTHON = 3U }; enum { PERL = 4U }; enum { JAVA = 5U }; enum { ZX81_BASIC = 6U }; enum { JAVASCRIPT2 = 7U }; }; class nsIClassInfo : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x986c11d0, 0xf340, 0x11d4, { 0x90, 0x75, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} virtual nsresult GetInterfaces(PRUint32 *count, nsIID * **array) = 0; virtual nsresult GetHelperForLanguage(PRUint32 language, nsISupports **_retval) = 0; virtual nsresult GetContractID(char * *aContractID) = 0; virtual nsresult GetClassDescription(char * *aClassDescription) = 0; virtual nsresult GetClassID(nsCID * *aClassID) = 0; virtual nsresult GetImplementationLanguage(PRUint32 *aImplementationLanguage) = 0; enum { SINGLETON = 1U }; enum { THREADSAFE = 2U }; enum { MAIN_THREAD_ONLY = 4U }; enum { DOM_OBJECT = 8U }; enum { PLUGIN_OBJECT = 16U }; enum { EAGER_CLASSINFO = 32U }; enum { RESERVED = 2147483648U }; virtual nsresult GetFlags(PRUint32 *aFlags) = 0; virtual nsresult GetClassIDNoAlloc(nsCID *aClassIDNoAlloc) = 0; }; extern "C" { typedef PRUint32 PRIntervalTime; extern PRIntervalTime PR_IntervalNow(void); extern PRUint32 PR_TicksPerSecond(void); extern PRIntervalTime PR_SecondsToInterval(PRUint32 seconds); extern PRIntervalTime PR_MillisecondsToInterval(PRUint32 milli); extern PRIntervalTime PR_MicrosecondsToInterval(PRUint32 micro); extern PRUint32 PR_IntervalToSeconds(PRIntervalTime ticks); extern PRUint32 PR_IntervalToMilliseconds(PRIntervalTime ticks); extern PRUint32 PR_IntervalToMicroseconds(PRIntervalTime ticks); } extern "C" { typedef struct PRMonitor PRMonitor; extern PRMonitor* PR_NewMonitor(void); extern void PR_DestroyMonitor(PRMonitor *mon); extern void PR_EnterMonitor(PRMonitor *mon); extern PRStatus PR_ExitMonitor(PRMonitor *mon); extern PRStatus PR_Wait(PRMonitor *mon, PRIntervalTime ticks); extern PRStatus PR_Notify(PRMonitor *mon); extern PRStatus PR_NotifyAll(PRMonitor *mon); } extern "C" { extern PRMonitor* PR_CEnterMonitor(void *address); extern PRStatus PR_CExitMonitor(void *address); extern PRStatus PR_CWait(void *address, PRIntervalTime timeout); extern PRStatus PR_CNotify(void *address); extern PRStatus PR_CNotifyAll(void *address); extern void PR_CSetOnMonitorRecycle(void ( *callback)(void *address)); } inline nsrefcnt NS_DebugGetRefCount( nsISupports* obj ) { nsrefcnt ref_count = 0; if ( obj ) { obj->AddRef(); ref_count = obj->Release(); if (!(ref_count)) nsDebug::Assertion("Oops! Calling |NS_DebugGetRefCount()| probably just " "destroyed this object.", "ref_count", "../../dist/include/xpcom/nsISupportsObsolete.h", 90); } return ref_count; } extern "C++" { template inline nsrefcnt ns_if_addref( T expr ) { return expr ? expr->AddRef() : 0; } } extern "C++" { class nsISupports; template struct nsCOMTypeInfo { static const nsIID& GetIID() { return T::GetIID(); } }; template <> struct nsCOMTypeInfo { static const nsIID& GetIID() { static const nsIID iid_NS_ISUPPORTS_IID = { 0x00000000, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }; return iid_NS_ISUPPORTS_IID; } }; template inline nsresult CallQueryInterface( T* aSource, DestinationType** aDestination ) { if (!(aSource)) nsDebug::PreCondition("null parameter", "aSource", "../../dist/include/xpcom/nsISupportsUtils.h", 266); if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsISupportsUtils.h", 267); return aSource->QueryInterface(nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } } class nsIFactory : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x00000001, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 }}; return iid;} virtual nsresult CreateInstance(nsISupports *aOuter, const nsIID & iid, void * *result) = 0; virtual nsresult LockFactory(PRBool lock) = 0; }; struct nsModuleComponentInfo; class nsIGenericFactory : public nsIFactory { public: static const nsIID& GetIID() {static const nsIID iid = { 0x3bc97f00, 0xccdf, 0x11d2, { 0xba, 0xb8, 0xb5, 0x48, 0x65, 0x44, 0x61, 0xfc } }; return iid;} virtual nsresult SetComponentInfo(nsModuleComponentInfo *info) = 0; virtual nsresult GetComponentInfo(nsModuleComponentInfo **infop) = 0; }; extern nsresult NS_NewGenericFactory(nsIGenericFactory **result, nsModuleComponentInfo *info); class nsIFile; class nsIComponentManager; class nsIModule : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x7392d032, 0x5371, 0x11d3, { 0x99, 0x4e, 0x00, 0x80, 0x5f, 0xd2, 0x6f, 0xee }}; return iid;} virtual nsresult GetClassObject(nsIComponentManager *aCompMgr, const nsCID & aClass, const nsIID & aIID, void * *result) = 0; virtual nsresult RegisterSelf(nsIComponentManager *aCompMgr, nsIFile *location, const char *registryLocation, const char *componentType) = 0; virtual nsresult UnregisterSelf(nsIComponentManager *aCompMgr, nsIFile *location, const char *registryLocation) = 0; virtual nsresult CanUnload(nsIComponentManager *aCompMgr, PRBool *_retval) = 0; }; extern "C" nsresult NSGetModule(nsIComponentManager *aCompMgr, nsIFile* location, nsIModule** return_cobj); typedef nsresult ( *nsGetModuleProc)(nsIComponentManager *aCompMgr, nsIFile* location, nsIModule** return_cobj); typedef nsresult (* NSConstructorProcPtr)(nsISupports *aOuter, const nsIID& aIID, void **aResult); typedef nsresult (* NSRegisterSelfProcPtr)(nsIComponentManager *aCompMgr, nsIFile *aPath, const char *aRegistryLocation, const char *aComponentType, const nsModuleComponentInfo *aInfo); typedef nsresult (* NSUnregisterSelfProcPtr)(nsIComponentManager *aCompMgr, nsIFile *aPath, const char *aRegistryLocation, const nsModuleComponentInfo *aInfo); typedef nsresult (* NSFactoryDestructorProcPtr)(void); typedef nsresult (* NSGetInterfacesProcPtr)(PRUint32 *countp, nsIID* **array); typedef nsresult (* NSGetLanguageHelperProcPtr)(PRUint32 language, nsISupports **helper); struct nsModuleComponentInfo { const char* mDescription; nsCID mCID; const char* mContractID; NSConstructorProcPtr mConstructor; NSRegisterSelfProcPtr mRegisterSelfProc; NSUnregisterSelfProcPtr mUnregisterSelfProc; NSFactoryDestructorProcPtr mFactoryDestructor; NSGetInterfacesProcPtr mGetInterfacesProc; NSGetLanguageHelperProcPtr mGetLanguageHelperProc; nsIClassInfo ** mClassInfoGlobal; PRUint32 mFlags; }; typedef nsresult ( *nsModuleConstructorProc) (nsIModule *self); typedef void ( *nsModuleDestructorProc) (nsIModule *self); struct nsModuleInfo { PRUint32 mVersion; const char* mModuleName; nsModuleComponentInfo* mComponents; PRUint32 mCount; nsModuleConstructorProc mCtor; nsModuleDestructorProc mDtor; }; extern nsresult NS_NewGenericModule2(nsModuleInfo *info, nsIModule* *result); extern nsresult NS_NewGenericModule(const char* moduleName, PRUint32 componentCount, nsModuleComponentInfo* components, nsModuleDestructorProc dtor, nsIModule* *result); class nsIFactory; class nsIComponentManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xa88e5a60, 0x205a, 0x4bb1, { 0x94, 0xe1, 0x26, 0x28, 0xda, 0xf5, 0x1e, 0xae }}; return iid;} virtual nsresult GetClassObject(const nsCID & aClass, const nsIID & aIID, void * *result) = 0; virtual nsresult GetClassObjectByContractID(const char *aContractID, const nsIID & aIID, void * *result) = 0; virtual nsresult CreateInstance(const nsCID & aClass, nsISupports *aDelegate, const nsIID & aIID, void * *result) = 0; virtual nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate, const nsIID & aIID, void * *result) = 0; }; typedef PRBool NSCAP_BOOL; template class nsDerivedSafe : public T { private: using T::AddRef; using T::Release; void operator delete( void*, size_t ); nsDerivedSafe& operator=( const T& ); }; template struct already_AddRefed { already_AddRefed( T* aRawPtr ) : mRawPtr(aRawPtr) { } T* get() const { return mRawPtr; } T* mRawPtr; }; template inline const already_AddRefed getter_AddRefs( T* aRawPtr ) { return already_AddRefed(aRawPtr); } template inline const already_AddRefed getter_AddRefs( const already_AddRefed& aAlreadyAddRefedPtr ) { return aAlreadyAddRefedPtr; } template inline const already_AddRefed dont_AddRef( T* aRawPtr ) { return already_AddRefed(aRawPtr); } template inline const already_AddRefed dont_AddRef( const already_AddRefed aAlreadyAddRefedPtr ) { return aAlreadyAddRefedPtr; } template inline T* dont_QueryInterface( T* expr ) { return expr; } class nsCOMPtr_helper { public: virtual nsresult operator()( const nsIID&, void** ) const = 0; }; class nsQueryInterface : public nsCOMPtr_helper { public: nsQueryInterface( nsISupports* aRawPtr, nsresult* error ) : mRawPtr(aRawPtr), mErrorPtr(error) { } virtual nsresult operator()( const nsIID& aIID, void** ) const; private: nsISupports* mRawPtr; nsresult* mErrorPtr; }; inline const nsQueryInterface do_QueryInterface( nsISupports* aRawPtr, nsresult* error = 0 ) { return nsQueryInterface(aRawPtr, error); } template inline void do_QueryInterface( already_AddRefed& ) { } template inline void do_QueryInterface( already_AddRefed&, nsresult* ) { } class nsCOMPtr_base { public: nsCOMPtr_base( nsISupports* rawPtr = 0 ) : mRawPtr(rawPtr) { } ~nsCOMPtr_base() { } void assign_with_AddRef( nsISupports* ); void assign_from_helper( const nsCOMPtr_helper&, const nsIID& ); void** begin_assignment(); protected: nsISupports* mRawPtr; void assign_assuming_AddRef( nsISupports* newPtr ) { nsISupports* oldPtr = mRawPtr; mRawPtr = newPtr; if ((newPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(newPtr)); if ( oldPtr ) ; if ((oldPtr)) { nsTraceRefcnt::LogReleaseCOMPtr((this),static_cast< nsISupports* >(oldPtr)); do { (oldPtr)->Release(); (oldPtr) = 0; } while (0); }; } }; template class nsCOMPtr { enum { _force_even_compliant_compilers_to_fail_ = sizeof(T) }; private: void assign_with_AddRef( nsISupports* ); void assign_from_helper( const nsCOMPtr_helper&, const nsIID& ); void** begin_assignment(); void assign_assuming_AddRef( T* newPtr ) { T* oldPtr = mRawPtr; mRawPtr = newPtr; if ((newPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(newPtr)); if ( oldPtr ) ; if ((oldPtr)) { nsTraceRefcnt::LogReleaseCOMPtr((this),static_cast< nsISupports* >(oldPtr)); do { (oldPtr)->Release(); (oldPtr) = 0; } while (0); }; } private: T* mRawPtr; public: typedef T element_type; ~nsCOMPtr() { if ( mRawPtr ) ; if ((mRawPtr)) { nsTraceRefcnt::LogReleaseCOMPtr((this),static_cast< nsISupports* >(mRawPtr)); do { (mRawPtr)->Release(); (mRawPtr) = 0; } while (0); }; } void Assert_NoQueryNeeded() { if ( mRawPtr ) { nsCOMPtr query_result( do_QueryInterface(mRawPtr) ); if (!(query_result.get() == mRawPtr)) nsDebug::Assertion("QueryInterface needed", "query_result.get() == mRawPtr", "../../dist/include/xpcom/nsCOMPtr.h", 501); } } nsCOMPtr() : mRawPtr(0) { if ((0)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(0)); } nsCOMPtr( const nsCOMPtr& aSmartPtr ) : mRawPtr(aSmartPtr.mRawPtr) { if ( mRawPtr ) (mRawPtr)->AddRef(); if ((aSmartPtr.mRawPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(aSmartPtr.mRawPtr)); } nsCOMPtr( T* aRawPtr ) : mRawPtr(aRawPtr) { if ( mRawPtr ) (mRawPtr)->AddRef(); if ((aRawPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(aRawPtr)); Assert_NoQueryNeeded();; } nsCOMPtr( const already_AddRefed& aSmartPtr ) : mRawPtr(aSmartPtr.mRawPtr) { if ((aSmartPtr.mRawPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(aSmartPtr.mRawPtr)); Assert_NoQueryNeeded();; } nsCOMPtr( const nsCOMPtr_helper& helper ) : mRawPtr(0) { if ((0)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(0)); assign_from_helper(helper, nsCOMTypeInfo::GetIID()); Assert_NoQueryNeeded();; } nsCOMPtr( const nsQueryInterface& helper ) : mRawPtr(0) { if ((0)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(0)); assign_from_helper(helper, nsCOMTypeInfo::GetIID()); } nsCOMPtr& operator=( const nsCOMPtr& rhs ) { assign_with_AddRef(rhs.mRawPtr); return *this; } nsCOMPtr& operator=( T* rhs ) { assign_with_AddRef(rhs); Assert_NoQueryNeeded();; return *this; } nsCOMPtr& operator=( const already_AddRefed& rhs ) { assign_assuming_AddRef(rhs.mRawPtr); Assert_NoQueryNeeded();; return *this; } nsCOMPtr& operator=( const nsCOMPtr_helper& rhs ) { assign_from_helper(rhs, nsCOMTypeInfo::GetIID()); Assert_NoQueryNeeded();; return *this; } nsCOMPtr& operator=( const nsQueryInterface& rhs ) { assign_from_helper(rhs, nsCOMTypeInfo::GetIID()); return *this; } nsDerivedSafe* get() const { return reinterpret_cast< nsDerivedSafe* >(mRawPtr); } operator nsDerivedSafe*() const { return get(); } nsDerivedSafe* operator->() const { if (!(mRawPtr != 0)) nsDebug::PreCondition("You can't dereference a NULL nsCOMPtr with operator->().", "mRawPtr != 0", "../../dist/include/xpcom/nsCOMPtr.h", 650); return get(); } nsCOMPtr* get_address() { return this; } const nsCOMPtr* get_address() const { return this; } private: const nsCOMPtr* operator&() const { return this; } nsCOMPtr* operator&() { return this; } public: nsDerivedSafe& operator*() const { if (!(mRawPtr != 0)) nsDebug::PreCondition("You can't dereference a NULL nsCOMPtr with operator*().", "mRawPtr != 0", "../../dist/include/xpcom/nsCOMPtr.h", 714); return *get(); } T** StartAssignment() { return reinterpret_cast< T** >(begin_assignment()); } }; template <> class nsCOMPtr : private nsCOMPtr_base { public: typedef nsISupports element_type; ~nsCOMPtr() { if ( mRawPtr ) ; if ((mRawPtr)) { nsTraceRefcnt::LogReleaseCOMPtr((this),static_cast< nsISupports* >(mRawPtr)); do { (mRawPtr)->Release(); (mRawPtr) = 0; } while (0); }; } nsCOMPtr() : nsCOMPtr_base(0) { if ((0)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(0)); } nsCOMPtr( const nsCOMPtr& aSmartPtr ) : nsCOMPtr_base(aSmartPtr.mRawPtr) { if ( mRawPtr ) (mRawPtr)->AddRef(); if ((aSmartPtr.mRawPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(aSmartPtr.mRawPtr)); } nsCOMPtr( nsISupports* aRawPtr ) : nsCOMPtr_base(aRawPtr) { if ( mRawPtr ) (mRawPtr)->AddRef(); if ((aRawPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(aRawPtr)); } nsCOMPtr( const already_AddRefed& aSmartPtr ) : nsCOMPtr_base(aSmartPtr.mRawPtr) { if ((aSmartPtr.mRawPtr)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(aSmartPtr.mRawPtr)); } nsCOMPtr( const nsCOMPtr_helper& helper ) : nsCOMPtr_base(0) { if ((0)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(0)); assign_from_helper(helper, nsCOMTypeInfo::GetIID()); } nsCOMPtr& operator=( const nsCOMPtr& rhs ) { assign_with_AddRef(rhs.mRawPtr); return *this; } nsCOMPtr& operator=( nsISupports* rhs ) { assign_with_AddRef(rhs); return *this; } nsCOMPtr& operator=( const already_AddRefed& rhs ) { assign_assuming_AddRef(rhs.mRawPtr); return *this; } nsCOMPtr& operator=( const nsCOMPtr_helper& rhs ) { assign_from_helper(rhs, nsCOMTypeInfo::GetIID()); return *this; } nsDerivedSafe* get() const { return reinterpret_cast< nsDerivedSafe* >(mRawPtr); } operator nsDerivedSafe*() const { return get(); } nsDerivedSafe* operator->() const { if (!(mRawPtr != 0)) nsDebug::PreCondition("You can't dereference a NULL nsCOMPtr with operator->().", "mRawPtr != 0", "../../dist/include/xpcom/nsCOMPtr.h", 871); return get(); } nsCOMPtr* get_address() { return this; } const nsCOMPtr* get_address() const { return this; } private: const nsCOMPtr* operator&() const { return this; } nsCOMPtr* operator&() { return this; } public: nsDerivedSafe& operator*() const { if (!(mRawPtr != 0)) nsDebug::PreCondition("You can't dereference a NULL nsCOMPtr with operator*().", "mRawPtr != 0", "../../dist/include/xpcom/nsCOMPtr.h", 936); return *get(); } nsISupports** StartAssignment() { return reinterpret_cast< nsISupports** >(begin_assignment()); } }; template void nsCOMPtr::assign_with_AddRef( nsISupports* rawPtr ) { if ( rawPtr ) (rawPtr)->AddRef(); assign_assuming_AddRef(reinterpret_cast< T* >(rawPtr)); } template void nsCOMPtr::assign_from_helper( const nsCOMPtr_helper& helper, const nsIID& aIID ) { T* newRawPtr; if ( ((helper(aIID, reinterpret_cast< void** >(&newRawPtr))) & 0x80000000) ) newRawPtr = 0; assign_assuming_AddRef(newRawPtr); } template void** nsCOMPtr::begin_assignment() { assign_assuming_AddRef(0); return reinterpret_cast< void** >(&mRawPtr); } template inline nsCOMPtr* address_of( nsCOMPtr& aPtr ) { return aPtr.get_address(); } template inline const nsCOMPtr* address_of( const nsCOMPtr& aPtr ) { return aPtr.get_address(); } template class nsGetterAddRefs { public: explicit nsGetterAddRefs( nsCOMPtr& aSmartPtr ) : mTargetSmartPtr(aSmartPtr) { } ~nsGetterAddRefs() { if ((mTargetSmartPtr.get())) nsTraceRefcnt::LogAddCOMPtr((reinterpret_cast< void * >(address_of(mTargetSmartPtr))),static_cast< nsISupports* >(mTargetSmartPtr.get())); mTargetSmartPtr.Assert_NoQueryNeeded(); } operator void**() { return reinterpret_cast< void** >(mTargetSmartPtr.StartAssignment()); } operator nsISupports**() { return reinterpret_cast< nsISupports** >(mTargetSmartPtr.StartAssignment()); } operator T**() { return mTargetSmartPtr.StartAssignment(); } T*& operator*() { return *(mTargetSmartPtr.StartAssignment()); } private: nsCOMPtr& mTargetSmartPtr; }; template <> class nsGetterAddRefs { public: explicit nsGetterAddRefs( nsCOMPtr& aSmartPtr ) : mTargetSmartPtr(aSmartPtr) { } ~nsGetterAddRefs() { if ((mTargetSmartPtr.get())) nsTraceRefcnt::LogAddCOMPtr((reinterpret_cast< void * >(address_of(mTargetSmartPtr))),static_cast< nsISupports* >(mTargetSmartPtr.get())); } operator void**() { return reinterpret_cast< void** >(mTargetSmartPtr.StartAssignment()); } operator nsISupports**() { return mTargetSmartPtr.StartAssignment(); } nsISupports*& operator*() { return *(mTargetSmartPtr.StartAssignment()); } private: nsCOMPtr& mTargetSmartPtr; }; template inline nsGetterAddRefs getter_AddRefs( nsCOMPtr& aSmartPtr ) { return nsGetterAddRefs(aSmartPtr); } template inline NSCAP_BOOL operator==( const nsCOMPtr& lhs, const nsCOMPtr& rhs ) { return static_cast< const void* >(lhs.get()) == static_cast< const void* >(rhs.get()); } template inline NSCAP_BOOL operator!=( const nsCOMPtr& lhs, const nsCOMPtr& rhs ) { return static_cast< const void* >(lhs.get()) != static_cast< const void* >(rhs.get()); } template inline NSCAP_BOOL operator==( const nsCOMPtr& lhs, const U* rhs ) { return static_cast< const void* >(lhs.get()) == static_cast< const void* >(rhs); } template inline NSCAP_BOOL operator==( const U* lhs, const nsCOMPtr& rhs ) { return static_cast< const void* >(lhs) == static_cast< const void* >(rhs.get()); } template inline NSCAP_BOOL operator!=( const nsCOMPtr& lhs, const U* rhs ) { return static_cast< const void* >(lhs.get()) != static_cast< const void* >(rhs); } template inline NSCAP_BOOL operator!=( const U* lhs, const nsCOMPtr& rhs ) { return static_cast< const void* >(lhs) != static_cast< const void* >(rhs.get()); } template inline NSCAP_BOOL operator==( const nsCOMPtr& lhs, U* rhs ) { return static_cast< const void* >(lhs.get()) == static_cast< void* >(rhs); } template inline NSCAP_BOOL operator==( U* lhs, const nsCOMPtr& rhs ) { return static_cast< void* >(lhs) == static_cast< const void* >(rhs.get()); } template inline NSCAP_BOOL operator!=( const nsCOMPtr& lhs, U* rhs ) { return static_cast< const void* >(lhs.get()) != static_cast< void* >(rhs); } template inline NSCAP_BOOL operator!=( U* lhs, const nsCOMPtr& rhs ) { return static_cast< void* >(lhs) != static_cast< const void* >(rhs.get()); } class NSCAP_Zero; template inline NSCAP_BOOL operator==( const nsCOMPtr& lhs, NSCAP_Zero* rhs ) { return static_cast< const void* >(lhs.get()) == reinterpret_cast< const void* >(rhs); } template inline NSCAP_BOOL operator==( NSCAP_Zero* lhs, const nsCOMPtr& rhs ) { return reinterpret_cast< const void* >(lhs) == static_cast< const void* >(rhs.get()); } template inline NSCAP_BOOL operator!=( const nsCOMPtr& lhs, NSCAP_Zero* rhs ) { return static_cast< const void* >(lhs.get()) != reinterpret_cast< const void* >(rhs); } template inline NSCAP_BOOL operator!=( NSCAP_Zero* lhs, const nsCOMPtr& rhs ) { return reinterpret_cast< const void* >(lhs) != static_cast< const void* >(rhs.get()); } inline NSCAP_BOOL SameCOMIdentity( nsISupports* lhs, nsISupports* rhs ) { return nsCOMPtr( do_QueryInterface(lhs) ) == nsCOMPtr( do_QueryInterface(rhs) ); } template inline nsresult CallQueryInterface( nsCOMPtr& aSourcePtr, DestinationType** aDestPtr ) { return CallQueryInterface(aSourcePtr.get(), aDestPtr); } class nsIFile; class nsIEnumerator; class nsIComponentManagerObsolete : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x8458a740, 0xd5dc, 0x11d2, { 0x92, 0xfb, 0x00, 0xe0, 0x98, 0x05, 0x57, 0x0f }}; return iid;} virtual nsresult FindFactory(const nsCID & aClass, nsIFactory **_retval) = 0; virtual nsresult GetClassObject(const nsCID & aClass, const nsIID & aIID, void * *_retval) = 0; virtual nsresult ContractIDToClassID(const char *aContractID, nsCID *aClass) = 0; virtual nsresult CLSIDToContractID(const nsCID & aClass, char **aClassName, char **_retval) = 0; virtual nsresult CreateInstance(const nsCID & aClass, nsISupports *aDelegate, const nsIID & aIID, void * *_retval) = 0; virtual nsresult CreateInstanceByContractID(const char *aContractID, nsISupports *aDelegate, const nsIID & IID, void * *_retval) = 0; virtual nsresult RegistryLocationForSpec(nsIFile *aSpec, char **_retval) = 0; virtual nsresult SpecForRegistryLocation(const char *aLocation, nsIFile **_retval) = 0; virtual nsresult RegisterFactory(const nsCID & aClass, const char *aClassName, const char *aContractID, nsIFactory *aFactory, PRBool aReplace) = 0; virtual nsresult RegisterComponent(const nsCID & aClass, const char *aClassName, const char *aContractID, const char *aLocation, PRBool aReplace, PRBool aPersist) = 0; virtual nsresult RegisterComponentWithType(const nsCID & aClass, const char *aClassName, const char *aContractID, nsIFile *aSpec, const char *aLocation, PRBool aReplace, PRBool aPersist, const char *aType) = 0; virtual nsresult RegisterComponentSpec(const nsCID & aClass, const char *aClassName, const char *aContractID, nsIFile *aLibrary, PRBool aReplace, PRBool aPersist) = 0; virtual nsresult RegisterComponentLib(const nsCID & aClass, const char *aClassName, const char *aContractID, const char *aDllName, PRBool aReplace, PRBool aPersist) = 0; virtual nsresult UnregisterFactory(const nsCID & aClass, nsIFactory *aFactory) = 0; virtual nsresult UnregisterComponent(const nsCID & aClass, const char *aLocation) = 0; virtual nsresult UnregisterComponentSpec(const nsCID & aClass, nsIFile *aLibrarySpec) = 0; virtual nsresult FreeLibraries(void) = 0; enum { NS_Startup = 0 }; enum { NS_Script = 1 }; enum { NS_Timer = 2 }; enum { NS_Shutdown = 3 }; virtual nsresult AutoRegister(PRInt32 when, nsIFile *directory) = 0; virtual nsresult AutoRegisterComponent(PRInt32 when, nsIFile *aFileLocation) = 0; virtual nsresult AutoUnregisterComponent(PRInt32 when, nsIFile *aFileLocation) = 0; virtual nsresult IsRegistered(const nsCID & aClass, PRBool *_retval) = 0; virtual nsresult EnumerateCLSIDs(nsIEnumerator **_retval) = 0; virtual nsresult EnumerateContractIDs(nsIEnumerator **_retval) = 0; }; class nsIEnumerator; class nsIFactory; class nsIFile; extern nsresult NS_GetGlobalComponentManager(nsIComponentManager* *result); class nsComponentManager { public: static nsresult Initialize(void); static nsresult FindFactory(const nsCID &aClass, nsIFactory **aFactory); static nsresult GetClassObject(const nsCID &aClass, const nsIID &aIID, void **aResult); static nsresult ContractIDToClassID(const char *aContractID, nsCID *aClass); static nsresult CLSIDToContractID(nsCID *aClass, char* *aClassName, char* *aContractID); static nsresult CreateInstance(const nsCID &aClass, nsISupports *aDelegate, const nsIID &aIID, void **aResult); static nsresult CreateInstance(const char *aContractID, nsISupports *aDelegate, const nsIID &aIID, void **aResult); static nsresult RegisterFactory(const nsCID &aClass, const char *aClassName, const char *aContractID, nsIFactory *aFactory, PRBool aReplace); static nsresult RegisterComponent(const nsCID &aClass, const char *aClassName, const char *aContractID, const char *aLibraryPersistentDescriptor, PRBool aReplace, PRBool aPersist); static nsresult RegisterComponentSpec(const nsCID &aClass, const char *aClassName, const char *aContractID, nsIFile *aLibrary, PRBool aReplace, PRBool aPersist); static nsresult RegisterComponentLib(const nsCID &aClass, const char *aClassName, const char *aContractID, const char *adllName, PRBool aReplace, PRBool aPersist); static nsresult UnregisterFactory(const nsCID &aClass, nsIFactory *aFactory); static nsresult UnregisterComponent(const nsCID &aClass, const char *aLibrary); static nsresult UnregisterComponentSpec(const nsCID &aClass, nsIFile *aLibrarySpec); static nsresult FreeLibraries(void); static nsresult AutoRegister(PRInt32 when, nsIFile* directory); static nsresult AutoRegisterComponent(PRInt32 when, nsIFile *component); static nsresult AutoUnregisterComponent(PRInt32 when, nsIFile *component); static nsresult IsRegistered(const nsCID &aClass, PRBool *aRegistered); static nsresult EnumerateCLSIDs(nsIEnumerator** aEmumerator); static nsresult EnumerateContractIDs(nsIEnumerator** aEmumerator); }; class nsCreateInstanceByCID : public nsCOMPtr_helper { public: nsCreateInstanceByCID( const nsCID& aCID, nsISupports* aOuter, nsresult* aErrorPtr ) : mCID(aCID), mOuter(aOuter), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID&, void** ) const; private: const nsCID& mCID; nsISupports* mOuter; nsresult* mErrorPtr; }; class nsCreateInstanceByContractID : public nsCOMPtr_helper { public: nsCreateInstanceByContractID( const char* aContractID, nsISupports* aOuter, nsresult* aErrorPtr ) : mContractID(aContractID), mOuter(aOuter), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID&, void** ) const; private: const char* mContractID; nsISupports* mOuter; nsresult* mErrorPtr; }; class nsCreateInstanceFromCategory : public nsCOMPtr_helper { public: nsCreateInstanceFromCategory(const char *aCategory, const char *aEntry, nsISupports *aOuter, nsresult *aErrorPtr) : mCategory(aCategory), mEntry(aEntry), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID&, void** ) const; virtual ~nsCreateInstanceFromCategory() {}; private: const char *mCategory; const char *mEntry; nsISupports *mOuter; nsresult *mErrorPtr; }; inline const nsCreateInstanceByCID do_CreateInstance( const nsCID& aCID, nsresult* error = 0 ) { return nsCreateInstanceByCID(aCID, 0, error); } inline const nsCreateInstanceByCID do_CreateInstance( const nsCID& aCID, nsISupports* aOuter, nsresult* error = 0 ) { return nsCreateInstanceByCID(aCID, aOuter, error); } inline const nsCreateInstanceByContractID do_CreateInstance( const char* aContractID, nsresult* error = 0 ) { return nsCreateInstanceByContractID(aContractID, 0, error); } inline const nsCreateInstanceByContractID do_CreateInstance( const char* aContractID, nsISupports* aOuter, nsresult* error = 0 ) { return nsCreateInstanceByContractID(aContractID, aOuter, error); } inline const nsCreateInstanceFromCategory do_CreateInstanceFromCategory( const char *aCategory, const char *aEntry, nsresult *aErrorPtr = 0) { return nsCreateInstanceFromCategory(aCategory, aEntry, 0, aErrorPtr); } inline const nsCreateInstanceFromCategory do_CreateInstanceFromCategory( const char *aCategory, const char *aEntry, nsISupports *aOuter, nsresult *aErrorPtr = 0) { return nsCreateInstanceFromCategory(aCategory, aEntry, aOuter, aErrorPtr); } template inline nsresult CallCreateInstance( const nsCID &aClass, nsISupports *aDelegate, DestinationType** aDestination ) { if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsComponentManagerUtils.h", 154); return nsComponentManager::CreateInstance(aClass, aDelegate, nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } template inline nsresult CallCreateInstance( const nsCID &aClass, DestinationType** aDestination ) { if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsComponentManagerUtils.h", 167); return nsComponentManager::CreateInstance(aClass, 0, nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } template inline nsresult CallCreateInstance( const char *aContractID, nsISupports *aDelegate, DestinationType** aDestination ) { if (!(aContractID)) nsDebug::PreCondition("null parameter", "aContractID", "../../dist/include/xpcom/nsComponentManagerUtils.h", 181); if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsComponentManagerUtils.h", 182); return nsComponentManager::CreateInstance(aContractID, aDelegate, nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } template inline nsresult CallCreateInstance( const char *aContractID, DestinationType** aDestination ) { if (!(aContractID)) nsDebug::PreCondition("null parameter", "aContractID", "../../dist/include/xpcom/nsComponentManagerUtils.h", 196); if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsComponentManagerUtils.h", 197); return nsComponentManager::CreateInstance(aContractID, 0, nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } extern const char xpcomKeyName[]; extern const char xpcomComponentsKeyName[]; extern const char lastModValueName[]; extern const char fileSizeValueName[]; extern const char nativeComponentType[]; extern const char staticComponentType[]; class nsIServiceManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x8bb35ed9, 0xe332, 0x462d, { 0x91, 0x55, 0x4a, 0x00, 0x2a, 0xb5, 0xc9, 0x58 }}; return iid;} virtual nsresult GetService(const nsCID & aClass, const nsIID & aIID, void * *result) = 0; virtual nsresult GetServiceByContractID(const char *aContractID, const nsIID & aIID, void * *result) = 0; virtual nsresult IsServiceInstantiated(const nsCID & aClass, const nsIID & aIID, PRBool *_retval) = 0; virtual nsresult IsServiceInstantiatedByContractID(const char *aContractID, const nsIID & aIID, PRBool *_retval) = 0; }; class nsIComponentManager; class nsIServiceManager; class nsIFile; class nsIDirectoryServiceProvider; class nsIMemory; extern "C" nsresult NS_InitXPCOM2(nsIServiceManager* *result, nsIFile* binDirectory, nsIDirectoryServiceProvider* appFileLocationProvider); extern "C" nsresult NS_ShutdownXPCOM(nsIServiceManager* servMgr); extern "C" nsresult NS_GetServiceManager(nsIServiceManager* *result); extern "C" nsresult NS_GetComponentManager(nsIComponentManager* *result); extern "C" nsresult NS_GetMemoryManager(nsIMemory* *result); class nsIServiceManager; class nsIShutdownListener; class nsIDirectoryServiceProvider; class nsServiceManagerObsolete; class nsIServiceManagerObsolete : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = { 0xcf0df3b0, 0x3401, 0x11d2, {0x81, 0x63, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a} }; return iid;}; virtual nsresult RegisterService(const nsCID& aClass, nsISupports* aService) = 0; virtual nsresult UnregisterService(const nsCID& aClass) = 0; virtual nsresult GetService(const nsCID& aClass, const nsIID& aIID, nsISupports* *result, nsIShutdownListener* shutdownListener = 0) = 0; virtual nsresult ReleaseService(const nsCID& aClass, nsISupports* service, nsIShutdownListener* shutdownListener = 0) = 0; virtual nsresult RegisterService(const char* aContractID, nsISupports* aService) = 0; virtual nsresult UnregisterService(const char* aContractID) = 0; virtual nsresult GetService(const char* aContractID, const nsIID& aIID, nsISupports* *result, nsIShutdownListener* shutdownListener = 0) = 0; virtual nsresult ReleaseService(const char* aContractID, nsISupports* service, nsIShutdownListener* shutdownListener = 0) = 0; }; class nsServiceManager { public: static nsresult RegisterService(const nsCID& aClass, nsISupports* aService); static nsresult UnregisterService(const nsCID& aClass); static nsresult GetService(const nsCID& aClass, const nsIID& aIID, nsISupports* *result, nsIShutdownListener* shutdownListener = 0); static nsresult ReleaseService(const nsCID& aClass, nsISupports* service, nsIShutdownListener* shutdownListener = 0); static nsresult RegisterService(const char* aContractID, nsISupports* aService); static nsresult UnregisterService(const char* aContractID); static nsresult GetService(const char* aContractID, const nsIID& aIID, nsISupports* *result, nsIShutdownListener* shutdownListener = 0); static nsresult ReleaseService(const char* aContractID, nsISupports* service, nsIShutdownListener* shutdownListener = 0); static nsresult GetGlobalServiceManager(nsIServiceManager* *result); static nsresult ShutdownGlobalServiceManager(nsIServiceManager* *result); }; class nsIShutdownListener; template inline nsresult CallGetService( const nsCID &aClass, nsIShutdownListener* shutdownListener, DestinationType** aDestination) { if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsIServiceManagerObsolete.h", 202); return nsServiceManager::GetService(aClass, nsCOMTypeInfo::GetIID(), reinterpret_cast< nsISupports** >(aDestination), shutdownListener); } template inline nsresult CallGetService( const char *aContractID, nsIShutdownListener* shutdownListener, DestinationType** aDestination) { if (!(aContractID)) nsDebug::PreCondition("null parameter", "aContractID", "../../dist/include/xpcom/nsIServiceManagerObsolete.h", 217); if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsIServiceManagerObsolete.h", 218); return nsServiceManager::GetService(aContractID, nsCOMTypeInfo::GetIID(), reinterpret_cast< nsISupports** >(aDestination), shutdownListener); } class nsGetServiceByCID : public nsCOMPtr_helper { public: nsGetServiceByCID( const nsCID& aCID, nsISupports* aServiceManager, nsresult* aErrorPtr ) : mCID(aCID), mServiceManager( do_QueryInterface(aServiceManager) ), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID&, void** ) const; virtual ~nsGetServiceByCID() {}; private: const nsCID& mCID; nsCOMPtr mServiceManager; nsresult* mErrorPtr; }; inline const nsGetServiceByCID do_GetService( const nsCID& aCID, nsresult* error = 0 ) { return nsGetServiceByCID(aCID, 0, error); } inline const nsGetServiceByCID do_GetService( const nsCID& aCID, nsISupports* aServiceManager, nsresult* error = 0 ) { return nsGetServiceByCID(aCID, aServiceManager, error); } class nsGetServiceByContractID : public nsCOMPtr_helper { public: nsGetServiceByContractID( const char* aContractID, nsISupports* aServiceManager, nsresult* aErrorPtr ) : mContractID(aContractID), mServiceManager( do_QueryInterface(aServiceManager) ), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID&, void** ) const; virtual ~nsGetServiceByContractID() {}; private: const char* mContractID; nsCOMPtr mServiceManager; nsresult* mErrorPtr; }; inline const nsGetServiceByContractID do_GetService( const char* aContractID, nsresult* error = 0 ) { return nsGetServiceByContractID(aContractID, 0, error); } inline const nsGetServiceByContractID do_GetService( const char* aContractID, nsISupports* aServiceManager, nsresult* error = 0 ) { return nsGetServiceByContractID(aContractID, aServiceManager, error); } class nsGetServiceFromCategory : public nsCOMPtr_helper { public: nsGetServiceFromCategory(const char* aCategory, const char* aEntry, nsISupports* aServiceManager, nsresult* aErrorPtr) : mCategory(aCategory), mEntry(aEntry), mServiceManager( do_QueryInterface(aServiceManager) ), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID&, void** ) const; virtual ~nsGetServiceFromCategory() {}; protected: const char* mCategory; const char* mEntry; nsCOMPtr mServiceManager; nsresult* mErrorPtr; }; inline const nsGetServiceFromCategory do_GetServiceFromCategory( const char* category, const char* entry, nsresult* error = 0) { return nsGetServiceFromCategory(category, entry, 0, error); } template inline nsresult CallGetService( const nsCID &aClass, DestinationType** aDestination) { if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsIServiceManagerUtils.h", 154); nsCOMPtr mgr; nsresult rv = NS_GetServiceManager(getter_AddRefs(mgr)); if (((rv) & 0x80000000)) return rv; return mgr->GetService(aClass, nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } template inline nsresult CallGetService( const char *aContractID, DestinationType** aDestination) { if (!(aContractID)) nsDebug::PreCondition("null parameter", "aContractID", "../../dist/include/xpcom/nsIServiceManagerUtils.h", 173); if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsIServiceManagerUtils.h", 174); nsCOMPtr mgr; nsresult rv = NS_GetServiceManager(getter_AddRefs(mgr)); if (((rv) & 0x80000000)) return rv; return mgr->GetServiceByContractID(aContractID, nsCOMTypeInfo::GetIID(), reinterpret_cast< void** >(aDestination)); } class nsISimpleEnumerator : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd1899240, 0xf9d2, 0x11d2, { 0xbd, 0xd6, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}; return iid;} virtual nsresult HasMoreElements(PRBool *_retval) = 0; virtual nsresult GetNext(nsISupports **_retval) = 0; }; class nsICategoryHandler : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x9c1af822, 0x1dd1, 0x11b2, { 0xb8, 0xce, 0xa1, 0xd2, 0x31, 0xc7, 0x95, 0x3f }}; return iid;} virtual nsresult GetCategoryEntry(const char *category, const char *entry, char **_retval) = 0; }; class nsICategoryManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x5a1e1a2c, 0x1dd2, 0x11b2, { 0xa7, 0x2f, 0x96, 0x73, 0x57, 0xe4, 0x3a, 0x00 }}; return iid;} virtual nsresult GetCategoryEntry(const char *aCategory, const char *aEntry, char **_retval) = 0; virtual nsresult GetCategoryEntryRaw(const char *aCategory, const char *aEntry, char **_retval) = 0; virtual nsresult AddCategoryEntry(const char *aCategory, const char *aEntry, const char *aValue, PRBool aPersist, PRBool aReplace, char **_retval) = 0; virtual nsresult DeleteCategoryEntry(const char *aCategory, const char *aEntry, PRBool aPersist) = 0; virtual nsresult DeleteCategory(const char *aCategory) = 0; virtual nsresult EnumerateCategory(const char *aCategory, nsISimpleEnumerator **_retval) = 0; virtual nsresult GetCategoryContents(const char *category, char ***entries, char ***values, PRUint32 *count) = 0; enum { OVERRIDE = 0 }; enum { FALLBACK = 1 }; virtual nsresult RegisterCategoryHandler(const char *aCategory, nsICategoryHandler *aHandler, PRInt32 aMode, nsICategoryHandler **_retval) = 0; virtual nsresult UnregisterCategoryHandler(const char *category, nsICategoryHandler *handler, nsICategoryHandler *previous) = 0; }; extern "C" nsresult NS_CategoryManagerGetFactory( nsIFactory** ); nsresult NS_CreateServicesFromCategory(const char *category, nsISupports *origin, const char *observerTopic); extern "C" { #ident "$Revision: 1.78 $" typedef struct { int quot; int rem; } div_t; typedef struct { long quot; long rem; } ldiv_t; extern "C" { #ident "$Revision: 1.4 $" typedef struct { unsigned int _class [ 257 ]; signed short _lower [ 257 ]; signed short _upper [ 257 ]; char _cswidth [ 7 ]; char _fill [ 1 ]; } __ctype_t; typedef int (*__isset_func_t)(int); typedef long wint_t; typedef int (*__iscodeset_func_t)(int, wint_t); typedef struct __attr { __ctype_t * _ctype_tbl; struct _csinfo { unsigned char _eucwidth[3]; unsigned char _scrwidth[3]; unsigned char _mb_cur_max; } _csinfo; struct _euc_func { int _is_euc; __isset_func_t _isset2; __isset_func_t _isset3; __iscodeset_func_t _iscodeset; } _euc_func; struct _collate_res { unsigned char _coll_as_cmp; } _collate_res; void * _fill[15]; } __attr_t; extern __attr_t __libc_attr; } extern double atof(const char *); extern int atoi(const char *); extern long int atol(const char *); extern double strtod(const char *, char **); extern long int strtol(const char *, char **, int); extern unsigned long int strtoul(const char *, char **, int); extern int rand(void); extern void srand(unsigned int); extern void *calloc(size_t, size_t); extern void free(void *); extern void *malloc(size_t); extern void *realloc(void *, size_t); extern void abort(void); extern int atexit(void (*)(void)); extern void exit(int); extern char *getenv(const char *); extern int system(const char *); extern void *bsearch(const void *, const void *, size_t, size_t, int (*)(const void *, const void *)); extern void qsort(void *, size_t, size_t, int (*)(const void *, const void *)); inline int abs(int x) {return x > 0 ? x : -x;} extern div_t div(int, int); extern long int labs(long); extern ldiv_t ldiv(long, long); extern int mbtowc(wchar_t *, const char *, size_t); extern int mblen(const char *, size_t); extern int wctomb(char *, wchar_t); extern size_t mbstowcs(wchar_t *, const char *, size_t); extern size_t wcstombs(char *, const wchar_t *, size_t); extern int putenv(const char *); extern double drand48(void); extern double erand48(unsigned short [3]); extern long lrand48(void); extern long nrand48(unsigned short [3]); extern long mrand48(void); extern long jrand48(unsigned short [3]); extern void srand48(long); extern void lcong48(unsigned short int [7]); extern void setkey(const char *); extern unsigned short * seed48(unsigned short int [3]); extern long a64l(const char *); extern char *ecvt(double, int, int *, int *); extern char *fcvt(double, int, int *, int *); extern char *gcvt(double, int, char *); extern int getsubopt(char **, char * const *, char **); extern int grantpt(int); extern char *initstate(unsigned int, char *, size_t); extern char *l64a(long); extern char *mktemp(char *); extern int mkstemp(char *); extern char *ptsname(int); extern long random(void); extern char *realpath(const char *, char *); extern char *setstate(const char *); extern void srandom(unsigned); extern int ttyslot(void); extern int unlockpt(int); extern void *valloc(size_t); extern int rand_r(unsigned int *); extern int atcheckpoint(void (*)(void)); extern int atrestart(void (*)(void)); extern int dup2(int, int); extern int getpw(int, char *); extern char *getcwd(char *, size_t); extern char *getlogin(void); extern char *getpass(const char *); extern int isatty(int); extern void l3tol(long *, const char *, int); extern void ltol3(char *, const long *, int); extern void *memalign(size_t, size_t); extern long double atold(const char *); extern long double strtold(const char *nptr, char **endptr); extern char *qecvt(long double, int, int *, int *); extern char *qfcvt(long double, int, int *, int *); extern char *qgcvt(long double, int, char *); extern char *ecvtl(long double, int, int *, int *); extern char *fcvtl(long double, int, int *, int *); extern char *gcvtl(long double, int, char *); typedef struct { __int64_t quot; __int64_t rem; } lldiv_t; extern __int64_t atoll(const char *); extern __int64_t strtoll(const char *, char **, int); extern __uint64_t strtoull(const char *, char **, int); extern __int64_t llabs(__int64_t); extern lldiv_t lldiv(__int64_t, __int64_t); extern char *ecvt_r(double, int, int *, int *, char *); extern char *fcvt_r(double, int, int *, int *, char *); extern char *qecvt_r(long double, int, int *, int *, char *); extern char *qfcvt_r(long double, int, int *, int *, char *); extern char *ecvtl_r(long double, int, int *, int *, char *); extern char *fcvtl_r(long double, int, int *, int *, char *); } extern "C" { extern PRUint32 PL_strlen(const char *str); extern PRUint32 PL_strnlen(const char *str, PRUint32 max); extern char * PL_strcpy(char *dest, const char *src); extern char * PL_strncpy(char *dest, const char *src, PRUint32 max); extern char * PL_strncpyz(char *dest, const char *src, PRUint32 max); extern char * PL_strdup(const char *s); extern void PL_strfree(char *s); extern char * PL_strndup(const char *s, PRUint32 max); extern char * PL_strcat(char *dst, const char *src); extern char * PL_strncat(char *dst, const char *src, PRUint32 max); extern char * PL_strcatn(char *dst, PRUint32 max, const char *src); extern PRIntn PL_strcmp(const char *a, const char *b); extern PRIntn PL_strncmp(const char *a, const char *b, PRUint32 max); extern PRIntn PL_strcasecmp(const char *a, const char *b); extern PRIntn PL_strncasecmp(const char *a, const char *b, PRUint32 max); extern char * PL_strchr(const char *s, char c); extern char * PL_strrchr(const char *s, char c); extern char * PL_strnchr(const char *s, char c, PRUint32 n); extern char * PL_strnrchr(const char *s, char c, PRUint32 n); extern char * PL_strpbrk(const char *s, const char *list); extern char * PL_strprbrk(const char *s, const char *list); extern char * PL_strnpbrk(const char *s, const char *list, PRUint32 n); extern char * PL_strnprbrk(const char *s, const char *list, PRUint32 n); extern char * PL_strstr(const char *big, const char *little); extern char * PL_strrstr(const char *big, const char *little); extern char * PL_strnstr(const char *big, const char *little, PRUint32 n); extern char * PL_strnrstr(const char *big, const char *little, PRUint32 max); extern char * PL_strcasestr(const char *big, const char *little); extern char * PL_strcaserstr(const char *big, const char *little); extern char * PL_strncasestr(const char *big, const char *little, PRUint32 max); extern char * PL_strncaserstr(const char *big, const char *little, PRUint32 max); extern char * PL_strtok_r(char *s1, const char *s2, char **lasts); } class nsIMemory : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x59e7e77a, 0x38e4, 0x11d4, { 0x8c, 0xf5, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} virtual void * Alloc(size_t size) = 0; virtual void * Realloc(void * ptr, size_t newSize) = 0; virtual void Free(void * ptr) = 0; virtual nsresult HeapMinimize(PRBool immediate) = 0; virtual nsresult IsLowMemory(PRBool *_retval) = 0; }; class nsMemory { public: static void* Alloc(size_t size); static void* Realloc(void* ptr, size_t size); static void Free(void* ptr); static nsresult HeapMinimize(PRBool aImmediate); static void* Clone(const void* ptr, size_t size); static nsIMemory* GetGlobalMemoryService(); }; namespace std { using ::ptrdiff_t; using ::size_t; } extern "C++" { namespace std { class exception { public: exception() throw() { } virtual ~exception() throw(); virtual const char* what() const throw(); }; class bad_exception : public exception { public: bad_exception() throw() { } virtual ~bad_exception() throw(); }; typedef void (*terminate_handler) (); typedef void (*unexpected_handler) (); terminate_handler set_terminate(terminate_handler) throw(); void terminate() __attribute__ ((__noreturn__)); unexpected_handler set_unexpected(unexpected_handler) throw(); void unexpected() __attribute__ ((__noreturn__)); bool uncaught_exception() throw(); } } extern "C++" { namespace std { class bad_alloc : public exception { public: bad_alloc() throw() { } virtual ~bad_alloc() throw(); }; struct nothrow_t { }; extern const nothrow_t nothrow; typedef void (*new_handler)(); new_handler set_new_handler(new_handler); } void *operator new(std::size_t) throw (std::bad_alloc); void *operator new[](std::size_t) throw (std::bad_alloc); void operator delete(void *) throw(); void operator delete[](void *) throw(); void *operator new(std::size_t, const std::nothrow_t&) throw(); void *operator new[](std::size_t, const std::nothrow_t&) throw(); void operator delete(void *, const std::nothrow_t&) throw(); void operator delete[](void *, const std::nothrow_t&) throw(); inline void *operator new(std::size_t, void *place) throw() { return place; } inline void *operator new[](std::size_t, void *place) throw() { return place; } } using std::bad_alloc; using std::nothrow_t; using std::nothrow; using std::new_handler; using std::set_new_handler; #ident "$Revision: 7.41 $" extern "C" { typedef union _h_val { unsigned long i[2]; double d; } _h_val; extern __const _h_val __huge_val; } template class nsCppSharedAllocator { public: typedef T value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; nsCppSharedAllocator() { } ~nsCppSharedAllocator() { } pointer address( reference r ) const { return &r; } const_pointer address( const_reference r ) const { return &r; } pointer allocate( size_type n, const void* =0 ) { return reinterpret_cast< pointer >(nsMemory::Alloc(static_cast< PRUint32 >(n*sizeof(T)))); } void deallocate( pointer p, size_type ) { nsMemory::Free(p); } void construct( pointer p, const T& val ) { new (p) T(val); } void destroy( pointer p ) { p->~T(); } size_type max_size() const { return (2147483647L * 2UL + 1) / sizeof(T); } }; template PRBool operator==( const nsCppSharedAllocator&, const nsCppSharedAllocator& ) { return 1; } template PRBool operator!=( const nsCppSharedAllocator&, const nsCppSharedAllocator& ) { return 0; } extern const PRUnichar kIsoLatin1ToUCS2[256]; class nsCRT { public: enum { TAB='\t' , LF='\n' , VTAB='\v' , FF='\f' , CR='\r' }; static void memcpy(void* aDest, const void* aSrc, PRUint32 aCount) { if (!((aDest != __null && aSrc != __null) || (aCount == 0))) nsDebug::Assertion("Invalid NULL argument", "(aDest != NULL && aSrc != NULL) || (aCount == 0)", "../../dist/include/xpcom/nsCRT.h", 122); ::memcpy(aDest, aSrc, (size_t)aCount); } static PRInt32 memcmp(const void* aDest, const void* aSrc, PRUint32 aCount) { if (!((aDest != __null && aSrc != __null) || (aCount == 0))) nsDebug::Assertion("Invalid NULL argument", "(aDest != NULL && aSrc != NULL) || (aCount == 0)", "../../dist/include/xpcom/nsCRT.h", 127); return ::memcmp(aDest, aSrc, (size_t)aCount); } static void memmove(void* aDest, const void* aSrc, PRUint32 aCount) { if (!((aDest != __null && aSrc != __null) || (aCount == 0))) nsDebug::Assertion("Invalid NULL argument", "(aDest != NULL && aSrc != NULL) || (aCount == 0)", "../../dist/include/xpcom/nsCRT.h", 132); ::memmove(aDest, aSrc, (size_t)aCount); } static void memset(void* aDest, PRUint8 aByte, PRUint32 aCount) { if (!((aDest != __null) || (aCount == 0))) nsDebug::Assertion("Invalid NULL argument", "(aDest != NULL) || (aCount == 0)", "../../dist/include/xpcom/nsCRT.h", 137); ::memset(aDest, aByte, aCount); } static void zero(void* aDest, PRUint32 aCount) { if (!((aDest != __null) || (aCount == 0))) nsDebug::Assertion("Invalid NULL argument", "(aDest != NULL) || (aCount == 0)", "../../dist/include/xpcom/nsCRT.h", 142); ::memset(aDest, 0, (size_t)aCount); } static PRUint32 strlen(const char* s) { return PRUint32(::strlen(s)); } static PRInt32 strcmp(const char* s1, const char* s2) { return PRInt32(PL_strcmp(s1, s2)); } static PRInt32 strncmp(const char* s1, const char* s2, PRUint32 aMaxLen) { return PRInt32(PL_strncmp(s1, s2, aMaxLen)); } static PRInt32 strcasecmp(const char* s1, const char* s2) { return PRInt32(PL_strcasecmp(s1, s2)); } static PRInt32 strncasecmp(const char* s1, const char* s2, PRUint32 aMaxLen) { PRInt32 result=PRInt32(PL_strncasecmp(s1, s2, aMaxLen)); if(result<0) result=-1; return result; } static PRInt32 strncmp(const char* s1, const char* s2, PRInt32 aMaxLen) { PRInt32 diff = ((const unsigned char*)s1)[0] - ((const unsigned char*)s2)[0]; if (diff != 0) return diff; return PRInt32(PL_strncmp(s1,s2,unsigned(aMaxLen))); } static char* strdup(const char* str) { return PL_strdup(str); } static char* strndup(const char* str, PRUint32 len) { return PL_strndup(str, len); } static void free(char* str) { PL_strfree(str); } static char* strtok(char* str, const char* delims, char* *newStr); static PRUint32 strlen(const PRUnichar* s); static PRInt32 strcmp(const PRUnichar* s1, const PRUnichar* s2); static PRInt32 strncmp(const PRUnichar* s1, const PRUnichar* s2, PRUint32 aMaxLen); static PRUnichar* strdup(const PRUnichar* str); static PRUnichar* strndup(const PRUnichar* str, PRUint32 len); static void free(PRUnichar* str) { nsCppSharedAllocator shared_allocator; shared_allocator.deallocate(str, 0 ); } static PRUint32 HashCode(const char* str, PRUint32* resultingStrLen = 0); static PRUint32 HashCode(const PRUnichar* str, PRUint32* resultingStrLen = 0); static PRUint32 BufferHashCode(const char* str, PRUint32 strLen); static PRInt64 atoll(const char *str); static char ToUpper(char aChar); static char ToLower(char aChar); static PRBool IsUpper(char aChar); static PRBool IsLower(char aChar); static PRBool IsAscii(PRUnichar aChar); static PRBool IsAscii(const PRUnichar* aString); static PRBool IsAsciiAlpha(PRUnichar aChar); static PRBool IsAsciiDigit(PRUnichar aChar); static PRBool IsAsciiSpace(PRUnichar aChar); static PRBool IsAscii(const char* aString); }; class nsIObserver; class nsISimpleEnumerator; class nsIObserverService : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd07f5192, 0xe3d1, 0x11d2, { 0x8a, 0xcd, 0x00, 0x10, 0x5a, 0x1b, 0x88, 0x60 }}; return iid;} virtual nsresult AddObserver(nsIObserver *anObserver, const char *aTopic, PRBool ownsWeak) = 0; virtual nsresult RemoveObserver(nsIObserver *anObserver, const char *aTopic) = 0; virtual nsresult NotifyObservers(nsISupports *aSubject, const char *aTopic, const PRUnichar *someData) = 0; virtual nsresult EnumerateObservers(const char *aTopic, nsISimpleEnumerator **_retval) = 0; }; extern "C" { typedef unsigned long prbitmap_t; extern PRIntn PR_CeilingLog2(PRUint32 i); extern PRIntn PR_FloorLog2(PRUint32 i); } typedef struct PRCListStr PRCList; struct PRCListStr { PRCList *next; PRCList *prev; }; extern "C" { typedef struct PRCondVar PRCondVar; extern PRCondVar* PR_NewCondVar(PRLock *lock); extern void PR_DestroyCondVar(PRCondVar *cvar); extern PRStatus PR_WaitCondVar(PRCondVar *cvar, PRIntervalTime timeout); extern PRStatus PR_NotifyCondVar(PRCondVar *cvar); extern PRStatus PR_NotifyAllCondVar(PRCondVar *cvar); } extern "C" { extern PRFloat64 PR_strtod(const char *s00, char **se); extern void PR_cnvtf(char *buf, PRIntn bufsz, PRIntn prcsn, PRFloat64 fval); extern PRStatus PR_dtoa(PRFloat64 d, PRIntn mode, PRIntn ndigits, PRIntn *decpt, PRIntn *sign, char **rve, char *buf, PRSize bufsize); } extern "C" { extern char* PR_GetEnv(const char *var); extern PRStatus PR_SetEnv(const char *string); } extern "C" { typedef PRInt32 PRErrorCode; extern void nspr_InitializePRErrorTable(void); extern void PR_SetError(PRErrorCode errorCode, PRInt32 oserr); extern void PR_SetErrorText( PRIntn textLength, const char *text); extern PRErrorCode PR_GetError(void); extern PRInt32 PR_GetOSError(void); extern PRInt32 PR_GetErrorTextLength(void); extern PRInt32 PR_GetErrorText(char *text); typedef PRUint32 PRLanguageCode; struct PRErrorMessage { const char * name; const char * en_text; }; struct PRErrorTable { const struct PRErrorMessage * msgs; const char *name; PRErrorCode base; int n_msgs; }; struct PRErrorCallbackPrivate; struct PRErrorCallbackTablePrivate; typedef const char * PRErrorCallbackLookupFn(PRErrorCode code, PRLanguageCode language, const struct PRErrorTable *table, struct PRErrorCallbackPrivate *cb_private, struct PRErrorCallbackTablePrivate *table_private); typedef struct PRErrorCallbackTablePrivate * PRErrorCallbackNewTableFn(const struct PRErrorTable *table, struct PRErrorCallbackPrivate *cb_private); extern const char * PR_ErrorToString(PRErrorCode code, PRLanguageCode language); extern const char * PR_ErrorToName(PRErrorCode code); extern const char * const * PR_ErrorLanguages(void); extern PRErrorCode PR_ErrorInstallTable(const struct PRErrorTable *table); extern void PR_ErrorInstallCallback(const char * const * languages, PRErrorCallbackLookupFn *lookup, PRErrorCallbackNewTableFn *newtable, struct PRErrorCallbackPrivate *cb_private); } extern "C" { struct linger { int l_onoff; int l_linger; }; typedef unsigned short sa_family_t; struct sockaddr { union { struct { sa_family_t sa_family2; char sa_data2[14]; } sa_generic; int sa_align; } sa_union; }; struct sockaddr_new { union { struct { u_char sa_len2; u_char sa_family2; char sa_data2[14]; } sa_generic; int sa_align; } sa_union; }; struct recvluinfo { struct mac_label *rlu_label; uid_t *rlu_uidp; }; struct sockproto { u_short sp_family; u_short sp_protocol; }; struct opthdr { int level; int name; int len; }; struct optdefault { int optname; char *val; int len; }; struct tpisocket; struct T_optmgmt_req; struct msgb; struct opproc { int level; int (*func)(struct tpisocket *, struct T_optmgmt_req *, struct opthdr *, struct msgb *); }; struct socksysreq { int args[7]; }; struct socknewproto { int family; int type; int proto; dev_t dev; int flags; }; typedef struct iovec { void *iov_base; size_t iov_len; } iovec_t; struct msghdr { caddr_t msg_name; int msg_namelen; struct iovec *msg_iov; int msg_iovlen; caddr_t msg_accrights; int msg_accrightslen; }; struct nmsghdr { caddr_t msg_name; int msg_namelen; struct iovec *msg_iov; int msg_iovlen; caddr_t msg_control; int msg_controllen; int msg_flags; }; struct xpg4_msghdr { void *msg_name; size_t msg_namelen; struct iovec *msg_iov; int msg_iovlen; void *msg_ctrl; size_t msg_ctrllen; int msg_flags; }; struct cmsghdr { size_t cmsg_len; int cmsg_level; int cmsg_type; }; extern int listen(int, int); extern int shutdown(int, int); extern int socketpair(int, int, int, int *); extern int recvmsg(int, struct msghdr *, int); extern int sendmsg(int, const struct msghdr *, int); extern int accept(int, void *, int *); extern int bind(int, const void *, int); extern int connect(int, const void *, int); extern int getpeername(int, void *, int *); extern int getsockname(int, void *, int *); extern int getsockopt(int, int, int, void *, int *); extern int recv(int, void *, int, int); extern int recvfrom(int, void *, int, int, void *, int *); extern int send(int, const void *, int, int); extern int sendto(int, const void *, int, int, const void *, int); extern int setsockopt(int, int, int, const void *, int); extern int socket(int, int, int); } extern "C" { #ident "$Revision: 1.8 $" typedef __uint32_t in_addr_t; typedef unsigned short in_port_t; struct in_addr { in_addr_t s_addr; }; struct sockaddr_in { sa_family_t sin_family; in_port_t sin_port; struct in_addr sin_addr; unsigned char sin_zero[8]; }; struct sockaddr_in_new { uchar_t sin_len; uchar_t sin_family; ushort_t sin_port; struct in_addr sin_addr; char sin_zero[8]; }; struct ip_opts { struct in_addr ip_dst; char ip_opts[40]; }; struct ip_mreq { struct in_addr imr_multiaddr; struct in_addr imr_interface; }; } #ident "$Revision: 1.12 $" extern "C" { extern in_addr_t inet_addr(const char *); extern in_addr_t inet_lnaof(struct in_addr); extern struct in_addr inet_makeaddr(in_addr_t, in_addr_t); extern in_addr_t inet_netof(struct in_addr); extern in_addr_t inet_network(const char *); extern char * inet_ntoa(struct in_addr); extern int inet_aton(const char *, struct in_addr *); extern int inet_pton(int, const char *, void *); extern const char * inet_ntop(int, const void *, char *, size_t); extern u_int inet_nsap_addr(const char *, u_char *, int); extern char * inet_nsap_ntoa(int, const u_char *, char *); extern int inet_isaddr(const char *, uint32_t *); } #ident "$Revision: 1.25 $" extern "C" { struct hostent { char *h_name; char **h_aliases; int h_addrtype; int h_length; char **h_addr_list; }; struct netent { char *n_name; char **n_aliases; int n_addrtype; in_addr_t n_net; }; struct servent { char *s_name; char **s_aliases; int s_port; char *s_proto; }; struct protoent { char *p_name; char **p_aliases; int p_proto; }; struct rpcent { char *r_name; char **r_aliases; int r_number; }; extern struct hostent *gethostbyaddr(const void *, int, int); extern struct hostent *gethostbyname(const char *), *gethostent(void); extern struct netent *getnetbyname(const char *), *getnetbyaddr(in_addr_t, int), *getnetent(void); extern struct servent *getservbyname(const char *, const char *), *getservbyport(int, const char *), *getservent(void); extern struct protoent *getprotobyname(const char *), *getprotobynumber(int), *getprotoent(void); extern void sethostent(int), endhostent(void), setnetent(int), endnetent(void), setservent(int), endservent(void), setprotoent(int), endprotoent(void); extern struct rpcent *getrpcbyname(const char *), *getrpcbynumber(int), *getrpcent(void); extern void setrpcent(int), endrpcent(void); extern int rcmd(char **, unsigned short, char *, char *, char *, int *); extern int rexec(char **, int, char *, char *, char *, int *); extern int rresvport(int *); extern int ruserok(char *, int, char *, char *); extern int h_errno; extern void herror(const char *); extern char *hstrerror(int); extern int innetgr(char *, char *, char *, char *); extern int getnetgrent(char **, char **, char **); extern void setnetgrent(char *); extern void endnetgrent(void); extern void sethostfile(char *); extern int sethostresorder(const char *); extern struct rpcent *getrpcbyname_r(const char *, struct rpcent *, char *, int), *getrpcbynumber_r(int, struct rpcent *, char *, int), *getrpcent_r(struct rpcent *, char *, int), *fgetrpcent(FILE *), *fgetrpcent_r(FILE *, struct rpcent *, char *, int); extern struct protoent *getprotobyname_r(const char *, struct protoent *, char *, int), *getprotobynumber_r(int, struct protoent *, char *, int), *getprotoent_r(struct protoent *, char *, int), *fgetprotoent(FILE *), *fgetprotoent_r(FILE *, struct protoent *, char *, int); extern struct servent *getservbyname_r(const char *, const char *, struct servent *, char *, int), *getservbyport_r(int, const char *, struct servent *, char *, int), *getservent_r(struct servent *, char *, int), *fgetservent(FILE *), *fgetservent_r(FILE *, struct servent *, char *, int); extern struct netent *getnetbyname_r(const char *, struct netent *, char *, int), *getnetbyaddr_r(in_addr_t, int, struct netent *, char *, int), *getnetent_r(struct netent *, char *, int), *fgetnetent(FILE *), *fgetnetent_r(FILE *, struct netent *, char *, int); extern struct hostent *gethostbyname_r(const char *, struct hostent *, char *, int, int *), *gethostbyaddr_r(const void *, size_t, int, struct hostent *, char *, int, int *), *gethostent_r(struct hostent *, char *, int), *fgethostent(FILE *), *fgethostent_r(FILE *, struct hostent *, char *, int); } extern "C" { typedef struct PRThread PRThread; typedef struct PRThreadStack PRThreadStack; typedef enum PRThreadType { PR_USER_THREAD, PR_SYSTEM_THREAD } PRThreadType; typedef enum PRThreadScope { PR_LOCAL_THREAD, PR_GLOBAL_THREAD, PR_GLOBAL_BOUND_THREAD } PRThreadScope; typedef enum PRThreadState { PR_JOINABLE_THREAD, PR_UNJOINABLE_THREAD } PRThreadState; typedef enum PRThreadPriority { PR_PRIORITY_FIRST = 0, PR_PRIORITY_LOW = 0, PR_PRIORITY_NORMAL = 1, PR_PRIORITY_HIGH = 2, PR_PRIORITY_URGENT = 3, PR_PRIORITY_LAST = 3 } PRThreadPriority; extern PRThread* PR_CreateThread(PRThreadType type, void ( *start)(void *arg), void *arg, PRThreadPriority priority, PRThreadScope scope, PRThreadState state, PRUint32 stackSize); extern PRStatus PR_JoinThread(PRThread *thread); extern PRThread* PR_GetCurrentThread(void); extern PRThreadPriority PR_GetThreadPriority(const PRThread *thread); extern void PR_SetThreadPriority(PRThread *thread, PRThreadPriority priority); typedef void ( *PRThreadPrivateDTOR)(void *priv); extern PRStatus PR_NewThreadPrivateIndex( PRUintn *newIndex, PRThreadPrivateDTOR destructor); extern PRStatus PR_SetThreadPrivate(PRUintn tpdIndex, void *priv); extern void* PR_GetThreadPrivate(PRUintn tpdIndex); extern PRStatus PR_Interrupt(PRThread *thread); extern void PR_ClearInterrupt(void); extern void PR_BlockInterrupt(void); extern void PR_UnblockInterrupt(void); extern PRStatus PR_Sleep(PRIntervalTime ticks); extern PRThreadScope PR_GetThreadScope(const PRThread *thread); extern PRThreadType PR_GetThreadType(const PRThread *thread); extern PRThreadState PR_GetThreadState(const PRThread *thread); } extern "C" { typedef PRBool (*PRVersionCheck)(const char*); extern PRBool PR_VersionCheck(const char *importedVersion); extern void PR_Init( PRThreadType type, PRThreadPriority priority, PRUintn maxPTDs); typedef PRIntn ( *PRPrimordialFn)(PRIntn argc, char **argv); extern PRIntn PR_Initialize( PRPrimordialFn prmain, PRIntn argc, char **argv, PRUintn maxPTDs); extern PRBool PR_Initialized(void); extern PRStatus PR_Cleanup(void); extern void PR_DisableClockInterrupts(void); extern void PR_EnableClockInterrupts(void); extern void PR_BlockClockInterrupts(void); extern void PR_UnblockClockInterrupts(void); extern void PR_SetConcurrency(PRUintn numCPUs); extern PRStatus PR_SetFDCacheSize(PRIntn low, PRIntn high); extern void PR_ProcessExit(PRIntn status); extern void PR_Abort(void); typedef struct PRCallOnceType { PRIntn initialized; PRInt32 inProgress; PRStatus status; } PRCallOnceType; typedef PRStatus ( *PRCallOnceFN)(void); extern PRStatus PR_CallOnce( PRCallOnceType *once, PRCallOnceFN func ); } extern "C" { typedef struct PRDir PRDir; typedef struct PRDirEntry PRDirEntry; typedef struct PRFileDesc PRFileDesc; typedef struct PRFileInfo PRFileInfo; typedef struct PRFileInfo64 PRFileInfo64; typedef union PRNetAddr PRNetAddr; typedef struct PRIOMethods PRIOMethods; typedef struct PRPollDesc PRPollDesc; typedef struct PRFilePrivate PRFilePrivate; typedef struct PRSendFileData PRSendFileData; typedef PRIntn PRDescIdentity; struct PRFileDesc { const PRIOMethods *methods; PRFilePrivate *secret; PRFileDesc *lower, *higher; void ( *dtor)(PRFileDesc *fd); PRDescIdentity identity; }; typedef enum PRTransmitFileFlags { PR_TRANSMITFILE_KEEP_OPEN = 0, PR_TRANSMITFILE_CLOSE_SOCKET = 1 } PRTransmitFileFlags; struct PRIPv6Addr { union { PRUint8 _S6_u8[16]; PRUint16 _S6_u16[8]; PRUint32 _S6_u32[4]; PRUint64 _S6_u64[2]; } _S6_un; }; typedef struct PRIPv6Addr PRIPv6Addr; union PRNetAddr { struct { PRUint16 family; char data[14]; } raw; struct { PRUint16 family; PRUint16 port; PRUint32 ip; char pad[8]; } inet; struct { PRUint16 family; PRUint16 port; PRUint32 flowinfo; PRIPv6Addr ip; PRUint32 scope_id; } ipv6; struct { PRUint16 family; char path[104]; } local; }; typedef enum PRSockOption { PR_SockOpt_Nonblocking, PR_SockOpt_Linger, PR_SockOpt_Reuseaddr, PR_SockOpt_Keepalive, PR_SockOpt_RecvBufferSize, PR_SockOpt_SendBufferSize, PR_SockOpt_IpTimeToLive, PR_SockOpt_IpTypeOfService, PR_SockOpt_AddMember, PR_SockOpt_DropMember, PR_SockOpt_McastInterface, PR_SockOpt_McastTimeToLive, PR_SockOpt_McastLoopback, PR_SockOpt_NoDelay, PR_SockOpt_MaxSegment, PR_SockOpt_Broadcast, PR_SockOpt_Last } PRSockOption; typedef struct PRLinger { PRBool polarity; PRIntervalTime linger; } PRLinger; typedef struct PRMcastRequest { PRNetAddr mcaddr; PRNetAddr ifaddr; } PRMcastRequest; typedef struct PRSocketOptionData { PRSockOption option; union { PRUintn ip_ttl; PRUintn mcast_ttl; PRUintn tos; PRBool non_blocking; PRBool reuse_addr; PRBool keep_alive; PRBool mcast_loopback; PRBool no_delay; PRBool broadcast; PRSize max_segment; PRSize recv_buffer_size; PRSize send_buffer_size; PRLinger linger; PRMcastRequest add_member; PRMcastRequest drop_member; PRNetAddr mcast_if; } value; } PRSocketOptionData; typedef struct PRIOVec { char *iov_base; int iov_len; } PRIOVec; typedef enum PRDescType { PR_DESC_FILE = 1, PR_DESC_SOCKET_TCP = 2, PR_DESC_SOCKET_UDP = 3, PR_DESC_LAYERED = 4, PR_DESC_PIPE = 5 } PRDescType; typedef enum PRSeekWhence { PR_SEEK_SET = 0, PR_SEEK_CUR = 1, PR_SEEK_END = 2 } PRSeekWhence; extern PRDescType PR_GetDescType(PRFileDesc *file); typedef PRStatus ( *PRCloseFN)(PRFileDesc *fd); typedef PRInt32 ( *PRReadFN)(PRFileDesc *fd, void *buf, PRInt32 amount); typedef PRInt32 ( *PRWriteFN)(PRFileDesc *fd, const void *buf, PRInt32 amount); typedef PRInt32 ( *PRAvailableFN)(PRFileDesc *fd); typedef PRInt64 ( *PRAvailable64FN)(PRFileDesc *fd); typedef PRStatus ( *PRFsyncFN)(PRFileDesc *fd); typedef PROffset32 ( *PRSeekFN)(PRFileDesc *fd, PROffset32 offset, PRSeekWhence how); typedef PROffset64 ( *PRSeek64FN)(PRFileDesc *fd, PROffset64 offset, PRSeekWhence how); typedef PRStatus ( *PRFileInfoFN)(PRFileDesc *fd, PRFileInfo *info); typedef PRStatus ( *PRFileInfo64FN)(PRFileDesc *fd, PRFileInfo64 *info); typedef PRInt32 ( *PRWritevFN)( PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size, PRIntervalTime timeout); typedef PRStatus ( *PRConnectFN)( PRFileDesc *fd, const PRNetAddr *addr, PRIntervalTime timeout); typedef PRFileDesc* ( *PRAcceptFN) ( PRFileDesc *fd, PRNetAddr *addr, PRIntervalTime timeout); typedef PRStatus ( *PRBindFN)(PRFileDesc *fd, const PRNetAddr *addr); typedef PRStatus ( *PRListenFN)(PRFileDesc *fd, PRIntn backlog); typedef PRStatus ( *PRShutdownFN)(PRFileDesc *fd, PRIntn how); typedef PRInt32 ( *PRRecvFN)( PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout); typedef PRInt32 ( *PRSendFN) ( PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout); typedef PRInt32 ( *PRRecvfromFN)( PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRNetAddr *addr, PRIntervalTime timeout); typedef PRInt32 ( *PRSendtoFN)( PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, const PRNetAddr *addr, PRIntervalTime timeout); typedef PRInt16 ( *PRPollFN)( PRFileDesc *fd, PRInt16 in_flags, PRInt16 *out_flags); typedef PRInt32 ( *PRAcceptreadFN)( PRFileDesc *sd, PRFileDesc **nd, PRNetAddr **raddr, void *buf, PRInt32 amount, PRIntervalTime t); typedef PRInt32 ( *PRTransmitfileFN)( PRFileDesc *sd, PRFileDesc *fd, const void *headers, PRInt32 hlen, PRTransmitFileFlags flags, PRIntervalTime t); typedef PRStatus ( *PRGetsocknameFN)(PRFileDesc *fd, PRNetAddr *addr); typedef PRStatus ( *PRGetpeernameFN)(PRFileDesc *fd, PRNetAddr *addr); typedef PRStatus ( *PRGetsocketoptionFN)( PRFileDesc *fd, PRSocketOptionData *data); typedef PRStatus ( *PRSetsocketoptionFN)( PRFileDesc *fd, const PRSocketOptionData *data); typedef PRInt32 ( *PRSendfileFN)( PRFileDesc *networkSocket, PRSendFileData *sendData, PRTransmitFileFlags flags, PRIntervalTime timeout); typedef PRStatus ( *PRConnectcontinueFN)( PRFileDesc *fd, PRInt16 out_flags); typedef PRIntn ( *PRReservedFN)(PRFileDesc *fd); struct PRIOMethods { PRDescType file_type; PRCloseFN close; PRReadFN read; PRWriteFN write; PRAvailableFN available; PRAvailable64FN available64; PRFsyncFN fsync; PRSeekFN seek; PRSeek64FN seek64; PRFileInfoFN fileInfo; PRFileInfo64FN fileInfo64; PRWritevFN writev; PRConnectFN connect; PRAcceptFN accept; PRBindFN bind; PRListenFN listen; PRShutdownFN shutdown; PRRecvFN recv; PRSendFN send; PRRecvfromFN recvfrom; PRSendtoFN sendto; PRPollFN poll; PRAcceptreadFN acceptread; PRTransmitfileFN transmitfile; PRGetsocknameFN getsockname; PRGetpeernameFN getpeername; PRReservedFN reserved_fn_6; PRReservedFN reserved_fn_5; PRGetsocketoptionFN getsocketoption; PRSetsocketoptionFN setsocketoption; PRSendfileFN sendfile; PRConnectcontinueFN connectcontinue; PRReservedFN reserved_fn_3; PRReservedFN reserved_fn_2; PRReservedFN reserved_fn_1; PRReservedFN reserved_fn_0; }; typedef enum PRSpecialFD { PR_StandardInput, PR_StandardOutput, PR_StandardError } PRSpecialFD; extern PRFileDesc* PR_GetSpecialFD(PRSpecialFD id); extern PRDescIdentity PR_GetUniqueIdentity(const char *layer_name); extern const char* PR_GetNameForIdentity(PRDescIdentity ident); extern PRDescIdentity PR_GetLayersIdentity(PRFileDesc* fd); extern PRFileDesc* PR_GetIdentitiesLayer(PRFileDesc* fd_stack, PRDescIdentity id); extern const PRIOMethods * PR_GetDefaultIOMethods(void); extern PRFileDesc* PR_CreateIOLayerStub( PRDescIdentity ident, const PRIOMethods *methods); extern PRFileDesc* PR_CreateIOLayer(PRFileDesc* fd); extern PRStatus PR_PushIOLayer( PRFileDesc *fd_stack, PRDescIdentity id, PRFileDesc *layer); extern PRFileDesc* PR_PopIOLayer(PRFileDesc *fd_stack, PRDescIdentity id); extern PRFileDesc* PR_Open(const char *name, PRIntn flags, PRIntn mode); extern PRFileDesc* PR_OpenFile( const char *name, PRIntn flags, PRIntn mode); extern PRStatus PR_Close(PRFileDesc *fd); extern PRInt32 PR_Read(PRFileDesc *fd, void *buf, PRInt32 amount); extern PRInt32 PR_Write(PRFileDesc *fd,const void *buf,PRInt32 amount); extern PRInt32 PR_Writev( PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size, PRIntervalTime timeout); extern PRStatus PR_Delete(const char *name); typedef enum PRFileType { PR_FILE_FILE = 1, PR_FILE_DIRECTORY = 2, PR_FILE_OTHER = 3 } PRFileType; struct PRFileInfo { PRFileType type; PROffset32 size; PRTime creationTime; PRTime modifyTime; }; struct PRFileInfo64 { PRFileType type; PROffset64 size; PRTime creationTime; PRTime modifyTime; }; extern PRStatus PR_GetFileInfo(const char *fn, PRFileInfo *info); extern PRStatus PR_GetFileInfo64(const char *fn, PRFileInfo64 *info); extern PRStatus PR_GetOpenFileInfo(PRFileDesc *fd, PRFileInfo *info); extern PRStatus PR_GetOpenFileInfo64(PRFileDesc *fd, PRFileInfo64 *info); extern PRStatus PR_Rename(const char *from, const char *to); typedef enum PRAccessHow { PR_ACCESS_EXISTS = 1, PR_ACCESS_WRITE_OK = 2, PR_ACCESS_READ_OK = 3 } PRAccessHow; extern PRStatus PR_Access(const char *name, PRAccessHow how); extern PROffset32 PR_Seek(PRFileDesc *fd, PROffset32 offset, PRSeekWhence whence); extern PROffset64 PR_Seek64(PRFileDesc *fd, PROffset64 offset, PRSeekWhence whence); extern PRInt32 PR_Available(PRFileDesc *fd); extern PRInt64 PR_Available64(PRFileDesc *fd); extern PRStatus PR_Sync(PRFileDesc *fd); struct PRDirEntry { const char *name; }; extern PRDir* PR_OpenDir(const char *name); typedef enum PRDirFlags { PR_SKIP_NONE = 0x0, PR_SKIP_DOT = 0x1, PR_SKIP_DOT_DOT = 0x2, PR_SKIP_BOTH = 0x3, PR_SKIP_HIDDEN = 0x4 } PRDirFlags; extern PRDirEntry* PR_ReadDir(PRDir *dir, PRDirFlags flags); extern PRStatus PR_CloseDir(PRDir *dir); extern PRStatus PR_MkDir(const char *name, PRIntn mode); extern PRStatus PR_MakeDir(const char *name, PRIntn mode); extern PRStatus PR_RmDir(const char *name); extern PRFileDesc* PR_NewUDPSocket(void); extern PRFileDesc* PR_NewTCPSocket(void); extern PRFileDesc* PR_OpenUDPSocket(PRIntn af); extern PRFileDesc* PR_OpenTCPSocket(PRIntn af); extern PRStatus PR_Connect( PRFileDesc *fd, const PRNetAddr *addr, PRIntervalTime timeout); extern PRStatus PR_ConnectContinue(PRFileDesc *fd, PRInt16 out_flags); extern PRStatus PR_GetConnectStatus(const PRPollDesc *pd); extern PRFileDesc* PR_Accept( PRFileDesc *fd, PRNetAddr *addr, PRIntervalTime timeout); extern PRStatus PR_Bind(PRFileDesc *fd, const PRNetAddr *addr); extern PRStatus PR_Listen(PRFileDesc *fd, PRIntn backlog); typedef enum PRShutdownHow { PR_SHUTDOWN_RCV = 0, PR_SHUTDOWN_SEND = 1, PR_SHUTDOWN_BOTH = 2 } PRShutdownHow; extern PRStatus PR_Shutdown(PRFileDesc *fd, PRShutdownHow how); extern PRInt32 PR_Recv(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout); extern PRInt32 PR_Send(PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout); extern PRInt32 PR_RecvFrom( PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRNetAddr *addr, PRIntervalTime timeout); extern PRInt32 PR_SendTo( PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, const PRNetAddr *addr, PRIntervalTime timeout); extern PRInt32 PR_TransmitFile( PRFileDesc *networkSocket, PRFileDesc *sourceFile, const void *headers, PRInt32 hlen, PRTransmitFileFlags flags, PRIntervalTime timeout); struct PRSendFileData { PRFileDesc *fd; PRUint32 file_offset; PRSize file_nbytes; const void *header; PRInt32 hlen; const void *trailer; PRInt32 tlen; }; extern PRInt32 PR_SendFile( PRFileDesc *networkSocket, PRSendFileData *sendData, PRTransmitFileFlags flags, PRIntervalTime timeout); extern PRInt32 PR_AcceptRead( PRFileDesc *listenSock, PRFileDesc **acceptedSock, PRNetAddr **peerAddr, void *buf, PRInt32 amount, PRIntervalTime timeout); extern PRStatus PR_NewTCPSocketPair(PRFileDesc *fds[2]); extern PRStatus PR_GetSockName(PRFileDesc *fd, PRNetAddr *addr); extern PRStatus PR_GetPeerName(PRFileDesc *fd, PRNetAddr *addr); extern PRStatus PR_GetSocketOption( PRFileDesc *fd, PRSocketOptionData *data); extern PRStatus PR_SetSocketOption( PRFileDesc *fd, const PRSocketOptionData *data); extern PRStatus PR_SetFDInheritable( PRFileDesc *fd, PRBool inheritable); extern PRFileDesc * PR_GetInheritedFD(const char *name); typedef struct PRFileMap PRFileMap; typedef enum PRFileMapProtect { PR_PROT_READONLY, PR_PROT_READWRITE, PR_PROT_WRITECOPY } PRFileMapProtect; extern PRFileMap * PR_CreateFileMap( PRFileDesc *fd, PRInt64 size, PRFileMapProtect prot); extern PRInt32 PR_GetMemMapAlignment(void); extern void * PR_MemMap( PRFileMap *fmap, PROffset64 offset, PRUint32 len); extern PRStatus PR_MemUnmap(void *addr, PRUint32 len); extern PRStatus PR_CloseFileMap(PRFileMap *fmap); extern PRStatus PR_CreatePipe( PRFileDesc **readPipe, PRFileDesc **writePipe ); struct PRPollDesc { PRFileDesc* fd; PRInt16 in_flags; PRInt16 out_flags; }; extern "C" { #ident "$Revision: 1.4 $" #ident "@(#)head:poll.h 1.2" #ident "$Revision: 1.42 $" extern "C" { typedef unsigned long nfds_t; struct pollfd { int fd; short events; short revents; }; extern int poll(struct pollfd *, nfds_t, int); } } extern PRInt32 PR_Poll( PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout); extern PRFileDesc * PR_NewPollableEvent(void); extern PRStatus PR_DestroyPollableEvent(PRFileDesc *event); extern PRStatus PR_SetPollableEvent(PRFileDesc *event); extern PRStatus PR_WaitForPollableEvent(PRFileDesc *event); } extern "C" { typedef struct PRSem PRSem; extern PRSem * PR_OpenSemaphore( const char *name, PRIntn flags, PRIntn mode, PRUintn value); extern PRStatus PR_WaitSemaphore(PRSem *sem); extern PRStatus PR_PostSemaphore(PRSem *sem); extern PRStatus PR_CloseSemaphore(PRSem *sem); extern PRStatus PR_DeleteSemaphore(const char *name); } extern "C" { typedef struct PRLibrary PRLibrary; typedef struct PRStaticLinkTable { const char *name; void (*fp)(); } PRStaticLinkTable; extern PRStatus PR_SetLibraryPath(const char *path); extern char* PR_GetLibraryPath(void); extern char* PR_GetLibraryName(const char *dir, const char *lib); extern void PR_FreeLibraryName(char *mem); extern PRLibrary* PR_LoadLibrary(const char *name); typedef enum PRLibSpecType { PR_LibSpec_Pathname, PR_LibSpec_MacNamedFragment, PR_LibSpec_MacIndexedFragment } PRLibSpecType; struct FSSpec; typedef struct PRLibSpec { PRLibSpecType type; union { const char *pathname; struct { const struct FSSpec *fsspec; const char *name; } mac_named_fragment; struct { const struct FSSpec *fsspec; PRUint32 index; } mac_indexed_fragment; } value; } PRLibSpec; extern PRLibrary * PR_LoadLibraryWithFlags( PRLibSpec libSpec, PRIntn flags ); extern PRStatus PR_UnloadLibrary(PRLibrary *lib); extern void* PR_FindSymbol(PRLibrary *lib, const char *name); typedef void (*PRFuncPtr)(); extern PRFuncPtr PR_FindFunctionSymbol(PRLibrary *lib, const char *name); extern void* PR_FindSymbolAndLibrary(const char *name, PRLibrary* *lib); extern PRFuncPtr PR_FindFunctionSymbolAndLibrary(const char *name, PRLibrary* *lib); extern PRLibrary* PR_LoadStaticLibrary( const char *name, const PRStaticLinkTable *table); } extern "C" { typedef enum PRLogModuleLevel { PR_LOG_NONE = 0, PR_LOG_ALWAYS = 1, PR_LOG_ERROR = 2, PR_LOG_WARNING = 3, PR_LOG_DEBUG = 4, PR_LOG_NOTICE = PR_LOG_DEBUG, PR_LOG_WARN = PR_LOG_WARNING, PR_LOG_MIN = PR_LOG_DEBUG, PR_LOG_MAX = PR_LOG_DEBUG } PRLogModuleLevel; typedef struct PRLogModuleInfo { const char *name; PRLogModuleLevel level; struct PRLogModuleInfo *next; } PRLogModuleInfo; extern PRLogModuleInfo* PR_NewLogModule(const char *name); extern PRBool PR_SetLogFile(const char *name); extern void PR_SetLogBuffering(PRIntn buffer_size); extern void PR_LogPrint(const char *fmt, ...); extern void PR_LogFlush(void); extern void PR_Assert(const char *s, const char *file, PRIntn ln); } extern "C" { extern void * PR_Malloc(PRUint32 size); extern void * PR_Calloc(PRUint32 nelem, PRUint32 elsize); extern void * PR_Realloc(void *ptr, PRUint32 size); extern void PR_Free(void *ptr); } extern "C" { typedef struct PRWaitGroup PRWaitGroup; typedef enum PRMWStatus { PR_MW_PENDING = 1, PR_MW_SUCCESS = 0, PR_MW_FAILURE = -1, PR_MW_TIMEOUT = -2, PR_MW_INTERRUPT = -3 } PRMWStatus; typedef struct PRMemoryDescriptor { void *start; PRSize length; } PRMemoryDescriptor; typedef struct PRMWaitClientData PRMWaitClientData; typedef struct PRRecvWait { PRCList internal; PRFileDesc *fd; PRMWStatus outcome; PRIntervalTime timeout; PRInt32 bytesRecv; PRMemoryDescriptor buffer; PRMWaitClientData *client; } PRRecvWait; typedef struct PRMWaitEnumerator PRMWaitEnumerator; extern PRStatus PR_AddWaitFileDesc(PRWaitGroup *group, PRRecvWait *desc); extern PRRecvWait* PR_WaitRecvReady(PRWaitGroup *group); extern PRStatus PR_CancelWaitFileDesc(PRWaitGroup *group, PRRecvWait *desc); extern PRRecvWait* PR_CancelWaitGroup(PRWaitGroup *group); extern PRWaitGroup* PR_CreateWaitGroup(PRInt32 size); extern PRStatus PR_DestroyWaitGroup(PRWaitGroup *group); extern PRMWaitEnumerator* PR_CreateMWaitEnumerator(PRWaitGroup *group); extern PRStatus PR_DestroyMWaitEnumerator(PRMWaitEnumerator* enumerator); extern PRRecvWait* PR_EnumerateWaitGroup( PRMWaitEnumerator *enumerator, const PRRecvWait *previous); } extern "C" { extern PRStatus PR_StringToNetAddr( const char *string, PRNetAddr *addr); extern PRStatus PR_NetAddrToString( const PRNetAddr *addr, char *string, PRUint32 size); typedef struct PRHostEnt { char *h_name; char **h_aliases; PRInt32 h_addrtype; PRInt32 h_length; char **h_addr_list; } PRHostEnt; extern PRStatus PR_GetHostByName( const char *hostname, char *buf, PRIntn bufsize, PRHostEnt *hostentry); extern PRStatus PR_GetIPNodeByName( const char *hostname, PRUint16 af, PRIntn flags, char *buf, PRIntn bufsize, PRHostEnt *hostentry); extern PRStatus PR_GetHostByAddr( const PRNetAddr *hostaddr, char *buf, PRIntn bufsize, PRHostEnt *hostentry); extern PRIntn PR_EnumerateHostEnt( PRIntn enumIndex, const PRHostEnt *hostEnt, PRUint16 port, PRNetAddr *address); typedef enum PRNetAddrValue { PR_IpAddrNull, PR_IpAddrAny, PR_IpAddrLoopback, PR_IpAddrV4Mapped } PRNetAddrValue; extern PRStatus PR_InitializeNetAddr( PRNetAddrValue val, PRUint16 port, PRNetAddr *addr); extern PRStatus PR_SetNetAddr( PRNetAddrValue val, PRUint16 af, PRUint16 port, PRNetAddr *addr); extern PRBool PR_IsNetAddrType(const PRNetAddr *addr, PRNetAddrValue val); extern void PR_ConvertIPv4AddrToIPv6(PRUint32 v4addr, PRIPv6Addr *v6addr); typedef struct PRProtoEnt { char *p_name; char **p_aliases; PRInt32 p_num; } PRProtoEnt; extern PRStatus PR_GetProtoByName( const char* protocolname, char* buffer, PRInt32 bufsize, PRProtoEnt* result); extern PRStatus PR_GetProtoByNumber( PRInt32 protocolnumber, char* buffer, PRInt32 bufsize, PRProtoEnt* result); extern PRUint16 PR_ntohs(PRUint16); extern PRUint32 PR_ntohl(PRUint32); extern PRUint64 PR_ntohll(PRUint64); extern PRUint16 PR_htons(PRUint16); extern PRUint32 PR_htonl(PRUint32); extern PRUint64 PR_htonll(PRUint64); } typedef __gnuc_va_list va_list; extern "C" { extern PRUint32 PR_snprintf(char *out, PRUint32 outlen, const char *fmt, ...); extern char* PR_smprintf(const char *fmt, ...); extern void PR_smprintf_free(char *mem); extern char* PR_sprintf_append(char *last, const char *fmt, ...); typedef PRIntn (*PRStuffFunc)(void *arg, const char *s, PRUint32 slen); extern PRUint32 PR_sxprintf(PRStuffFunc f, void *arg, const char *fmt, ...); extern PRUint32 PR_fprintf(struct PRFileDesc* fd, const char *fmt, ...); extern PRUint32 PR_vsnprintf(char *out, PRUint32 outlen, const char *fmt, va_list ap); extern char* PR_vsmprintf(const char *fmt, va_list ap); extern char* PR_vsprintf_append(char *last, const char *fmt, va_list ap); extern PRUint32 PR_vsxprintf(PRStuffFunc f, void *arg, const char *fmt, va_list ap); extern PRUint32 PR_vfprintf(struct PRFileDesc* fd, const char *fmt, va_list ap); extern PRInt32 PR_sscanf(const char *buf, const char *fmt, ...); } extern "C" { typedef struct PRProcess PRProcess; typedef struct PRProcessAttr PRProcessAttr; extern PRProcessAttr * PR_NewProcessAttr(void); extern void PR_ResetProcessAttr(PRProcessAttr *attr); extern void PR_DestroyProcessAttr(PRProcessAttr *attr); extern void PR_ProcessAttrSetStdioRedirect( PRProcessAttr *attr, PRSpecialFD stdioFd, PRFileDesc *redirectFd ); extern void PR_SetStdioRedirect( PRProcessAttr *attr, PRSpecialFD stdioFd, PRFileDesc *redirectFd ); extern PRStatus PR_ProcessAttrSetCurrentDirectory( PRProcessAttr *attr, const char *dir ); extern PRStatus PR_ProcessAttrSetInheritableFD( PRProcessAttr *attr, PRFileDesc *fd, const char *name ); extern PRProcess* PR_CreateProcess( const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr); extern PRStatus PR_CreateProcessDetached( const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr); extern PRStatus PR_DetachProcess(PRProcess *process); extern PRStatus PR_WaitProcess(PRProcess *process, PRInt32 *exitCode); extern PRStatus PR_KillProcess(PRProcess *process); } extern "C" { extern PRSize PR_GetRandomNoise( void *buf, PRSize size ); } extern "C" { typedef struct PRRWLock PRRWLock; extern PRRWLock* PR_NewRWLock(PRUint32 lock_rank, const char *lock_name); extern void PR_DestroyRWLock(PRRWLock *lock); extern void PR_RWLock_Rlock(PRRWLock *lock); extern void PR_RWLock_Wlock(PRRWLock *lock); extern void PR_RWLock_Unlock(PRRWLock *lock); } extern "C" { typedef struct PRSharedMemory PRSharedMemory; extern PRSharedMemory * PR_OpenSharedMemory( const char *name, PRSize size, PRIntn flags, PRIntn mode ); extern void * PR_AttachSharedMemory( PRSharedMemory *shm, PRIntn flags ); extern PRStatus PR_DetachSharedMemory( PRSharedMemory *shm, void *addr ); extern PRStatus PR_CloseSharedMemory( PRSharedMemory *shm ); extern PRStatus PR_DeleteSharedMemory( const char *name ); } extern "C" { extern PRFileMap * PR_OpenAnonFileMap( const char *dirName, PRSize size, PRFileMapProtect prot ); extern PRStatus PR_ProcessAttrSetInheritableFileMap( PRProcessAttr *attr, PRFileMap *fm, const char *shmname ); extern PRFileMap * PR_GetInheritedFileMap( const char *shmname ); extern PRStatus PR_ExportFileMapAsString( PRFileMap *fm, PRSize bufsize, char *buf ); extern PRFileMap * PR_ImportFileMapFromString( const char *fmstring ); } extern "C" { extern char PR_GetDirectorySeparator(void); extern char PR_GetDirectorySepartor(void); typedef enum { PR_SI_HOSTNAME, PR_SI_SYSNAME, PR_SI_RELEASE, PR_SI_ARCHITECTURE } PRSysInfo; extern PRStatus PR_GetSystemInfo(PRSysInfo cmd, char *buf, PRUint32 buflen); extern PRInt32 PR_GetPageSize(void); extern PRInt32 PR_GetPageShift(void); extern PRInt32 PR_GetNumberOfProcessors( void ); } extern "C" { typedef struct PRJobIoDesc { PRFileDesc *socket; PRErrorCode error; PRIntervalTime timeout; } PRJobIoDesc; typedef struct PRThreadPool PRThreadPool; typedef struct PRJob PRJob; typedef void ( *PRJobFn) (void *arg); extern PRThreadPool * PR_CreateThreadPool(PRInt32 initial_threads, PRInt32 max_threads, PRUint32 stacksize); extern PRJob * PR_QueueJob(PRThreadPool *tpool, PRJobFn fn, void *arg, PRBool joinable); extern PRJob * PR_QueueJob_Read(PRThreadPool *tpool, PRJobIoDesc *iod, PRJobFn fn, void * arg, PRBool joinable); extern PRJob * PR_QueueJob_Write(PRThreadPool *tpool, PRJobIoDesc *iod, PRJobFn fn, void * arg, PRBool joinable); extern PRJob * PR_QueueJob_Accept(PRThreadPool *tpool, PRJobIoDesc *iod, PRJobFn fn, void * arg, PRBool joinable); extern PRJob * PR_QueueJob_Connect(PRThreadPool *tpool, PRJobIoDesc *iod, const PRNetAddr *addr, PRJobFn fn, void * arg, PRBool joinable); extern PRJob * PR_QueueJob_Timer(PRThreadPool *tpool, PRIntervalTime timeout, PRJobFn fn, void * arg, PRBool joinable); extern PRStatus PR_CancelJob(PRJob *job); extern PRStatus PR_JoinJob(PRJob *job); extern PRStatus PR_ShutdownThreadPool(PRThreadPool *tpool); extern PRStatus PR_JoinThreadPool(PRThreadPool *tpool); } extern "C" { typedef void * PRTraceHandle; typedef struct PRTraceEntry { PRThread *thread; PRTraceHandle handle; PRTime time; PRUint32 userData[8]; } PRTraceEntry; typedef enum PRTraceOption { PRTraceBufSize, PRTraceEnable, PRTraceDisable, PRTraceSuspend, PRTraceResume, PRTraceSuspendRecording, PRTraceResumeRecording, PRTraceLockHandles, PRTraceUnLockHandles, PRTraceStopRecording } PRTraceOption; extern PRTraceHandle PR_CreateTrace( const char *qName, const char *rName, const char *description ); extern void PR_DestroyTrace( PRTraceHandle handle ); extern void PR_Trace( PRTraceHandle handle, PRUint32 userData0, PRUint32 userData1, PRUint32 userData2, PRUint32 userData3, PRUint32 userData4, PRUint32 userData5, PRUint32 userData6, PRUint32 userData7 ); extern void PR_SetTraceOption( PRTraceOption command, void *value ); extern void PR_GetTraceOption( PRTraceOption command, void *value ); extern PRTraceHandle PR_GetTraceHandleFromName( const char *qName, const char *rName ); extern void PR_GetTraceNameFromHandle( PRTraceHandle handle, const char **qName, const char **rName, const char **description ); extern PRTraceHandle PR_FindNextTraceQname( PRTraceHandle handle ); extern PRTraceHandle PR_FindNextTraceRname( PRTraceHandle rhandle, PRTraceHandle qhandle ); extern void PR_RecordTraceEntries( void ); extern PRIntn PR_GetTraceEntries( PRTraceEntry *buffer, PRInt32 count, PRInt32 *found ); } class nsAString; class nsACString; class nsAPromiseString; class nsAPromiseCString; class nsAFlatString; class nsAFlatCString; class nsDependentString; class nsDependentCString; template class nsBufferHandle { public: typedef PRUint32 size_type; nsBufferHandle() { } nsBufferHandle( CharT* aDataStart, CharT* aDataEnd ) : mDataStart(aDataStart), mDataEnd(aDataEnd) { } void DataStart( CharT* aNewDataStart ) { mDataStart = aNewDataStart; } CharT* DataStart() { return mDataStart; } const CharT* DataStart() const { return mDataStart; } void DataEnd( CharT* aNewDataEnd ) { mDataEnd = aNewDataEnd; } CharT* DataEnd() { return mDataEnd; } const CharT* DataEnd() const { return mDataEnd; } size_type DataLength() const { return mDataEnd - mDataStart; } protected: CharT* mDataStart; CharT* mDataEnd; }; template class nsConstBufferHandle { public: typedef PRUint32 size_type; nsConstBufferHandle() { } nsConstBufferHandle( const CharT* aDataStart, const CharT* aDataEnd ) : mDataStart(aDataStart), mDataEnd(aDataEnd) { } void DataStart( const CharT* aNewDataStart ) { mDataStart = aNewDataStart; } const CharT* DataStart() const { return mDataStart; } void DataEnd( const CharT* aNewDataEnd ) { mDataEnd = aNewDataEnd; } const CharT* DataEnd() const { return mDataEnd; } size_type DataLength() const { return mDataEnd - mDataStart; } protected: const CharT* mDataStart; const CharT* mDataEnd; }; template class nsStringAllocator { public: virtual void Deallocate( CharT* ) const = 0; }; nsStringAllocator& StringAllocator_char(); nsStringAllocator& StringAllocator_wchar_t(); template struct nsStringAllocatorTraits { }; template <> struct nsStringAllocatorTraits { static nsStringAllocator& global_string_allocator() { return StringAllocator_char(); } }; template <> struct nsStringAllocatorTraits { static nsStringAllocator& global_string_allocator() { return StringAllocator_wchar_t(); } }; template class nsSharedBufferHandle : public nsBufferHandle { public: typedef PRUint32 size_type; protected: enum { kIsImmutable = 0x01000000, kIsSingleAllocationWithBuffer = 0x02000000, kIsUserAllocator = 0x04000000, kIsNULL = 0x80000000, kImplementationFlagsMask = 0xF0000000, kFlagsMask = 0xFF000000, kRefCountMask = 0x00FFFFFF }; public: nsSharedBufferHandle( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength, PRBool isSingleAllocation ) : nsBufferHandle(aDataStart, aDataEnd), mFlags(0), mStorageLength(aStorageLength) { if ( isSingleAllocation ) mFlags |= kIsSingleAllocationWithBuffer; } ~nsSharedBufferHandle(); void AcquireReference() const { nsSharedBufferHandle* mutable_this = const_cast< nsSharedBufferHandle* >(this); mutable_this->set_refcount( get_refcount()+1 ); } void ReleaseReference() const; PRBool IsReferenced() const { return get_refcount() != 0; } PRBool IsMutable() const { return (mFlags & (kRefCountMask | kIsImmutable) == 1); } void StorageLength( size_type aNewStorageLength ) { mStorageLength = aNewStorageLength; } size_type StorageLength() const { return mStorageLength; } PRUint32 GetImplementationFlags() const { return mFlags & kImplementationFlagsMask; } void SetImplementationFlags( PRUint32 aNewFlags ) { mFlags = (mFlags & ~kImplementationFlagsMask) | (aNewFlags & kImplementationFlagsMask); } protected: PRUint32 mFlags; size_type mStorageLength; PRUint32 get_refcount() const { return mFlags & kRefCountMask; } PRUint32 set_refcount( PRUint32 aNewRefCount ) { if (!(aNewRefCount <= kRefCountMask)) nsDebug::Assertion("aNewRefCount <= kRefCountMask", "aNewRefCount <= kRefCountMask", "../../dist/include/string/nsBufferHandle.h", 274); mFlags = (mFlags & kFlagsMask) | aNewRefCount; return aNewRefCount; } nsStringAllocator& get_allocator() const; }; template class nsSharedBufferHandleWithAllocator : public nsSharedBufferHandle { public: typedef PRUint32 size_type; nsSharedBufferHandleWithAllocator( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength, nsStringAllocator& aAllocator ) : nsSharedBufferHandle(aDataStart, aDataEnd, aStorageLength, 0), mAllocator(aAllocator) { this->mFlags |= this->kIsUserAllocator; } nsStringAllocator& get_allocator() const { return mAllocator; } protected: nsStringAllocator& mAllocator; }; template class nsSharedBufferHandleWithDestroy : public nsSharedBufferHandle { public: typedef PRUint32 size_type; nsSharedBufferHandleWithDestroy( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength) : nsSharedBufferHandle(aDataStart, aDataEnd, aStorageLength, 0) { this->mFlags |= this->kIsUserAllocator | this->kIsSingleAllocationWithBuffer; } virtual void Destroy() = 0; virtual ~nsSharedBufferHandleWithDestroy() { } }; template class nsNonDestructingSharedBufferHandle : public nsSharedBufferHandleWithDestroy { public: typedef PRUint32 size_type; nsNonDestructingSharedBufferHandle( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength) : nsSharedBufferHandleWithDestroy(aDataStart, aDataEnd, aStorageLength) { } virtual void Destroy() { this->set_refcount(1); } }; template nsStringAllocator& nsSharedBufferHandle::get_allocator() const { if ( mFlags & kIsUserAllocator ) { return reinterpret_cast< const nsSharedBufferHandleWithAllocator* >(this)->get_allocator(); } return nsStringAllocatorTraits::global_string_allocator(); } template nsSharedBufferHandle::~nsSharedBufferHandle() { if (!(!IsReferenced())) nsDebug::Assertion("!IsReferenced()", "!IsReferenced()", "../../dist/include/string/nsBufferHandle.h", 376); if ( !(mFlags & kIsSingleAllocationWithBuffer) ) { CharT* string_storage = this->mDataStart; get_allocator().Deallocate(string_storage); } } template void nsSharedBufferHandle::ReleaseReference() const { nsSharedBufferHandle* mutable_this = const_cast< nsSharedBufferHandle* >(this); if ( !mutable_this->set_refcount( get_refcount()-1 ) ) { if ( ~mFlags & (kIsUserAllocator|kIsSingleAllocationWithBuffer) ) delete mutable_this; else static_cast< nsSharedBufferHandleWithDestroy* >(mutable_this)->Destroy(); } } extern "C" { #ident "$Revision: 1.29 $" extern int isalnum(int); extern int isalpha(int); extern int iscntrl(int); extern int isdigit(int); extern int isgraph(int); extern int islower(int); extern int isprint(int); extern int ispunct(int); extern int isspace(int); extern int __isblank(int); extern int isupper(int); extern int isxdigit(int); extern int tolower(int); extern int toupper(int); extern int isascii(int); extern int toascii(int); extern int _tolower(int); extern int _toupper(int); } template inline PRBool SameFragment( const Iterator& lhs, const Iterator& rhs ) { return lhs.fragment().mStart == rhs.fragment().mStart; } template class nsReadingIterator; size_t Distance( const nsReadingIterator&, const nsReadingIterator& ); size_t Distance( const nsReadingIterator&, const nsReadingIterator& ); typedef PRBool nsCharTraits_bool; template struct nsCharTraits {}; template <> struct nsCharTraits { typedef PRUnichar char_type; typedef PRUint16 unsigned_char_type; typedef char incompatible_char_type; static void assign( char_type& lhs, char_type rhs ) { lhs = rhs; } typedef int int_type; static char_type to_char_type( int_type c ) { return char_type(c); } static int_type to_int_type( char_type c ) { return int_type( static_cast< unsigned_char_type >(c) ); } static nsCharTraits_bool eq_int_type( int_type lhs, int_type rhs ) { return lhs == rhs; } static nsCharTraits_bool eq( char_type lhs, char_type rhs ) { return lhs == rhs; } static nsCharTraits_bool lt( char_type lhs, char_type rhs ) { return lhs < rhs; } static char_type* move( char_type* s1, const char_type* s2, size_t n ) { return static_cast< char_type* >(memmove(s1, s2, n * sizeof(char_type))); } static char_type* copy( char_type* s1, const char_type* s2, size_t n ) { return static_cast< char_type* >(memcpy(s1, s2, n * sizeof(char_type))); } static char_type* assign( char_type* s, size_t n, char_type c ) { char_type* result = s; while ( n-- ) assign(*s++, c); return result; } static int compare( const char_type* s1, const char_type* s2, size_t n ) { return memcmp(s1, s2, n * sizeof(char_type)); } static size_t length( const char_type* s ) { size_t result = 0; while ( !eq(*s++, char_type(0)) ) ++result; return result; } static const char_type* find( const char_type* s, size_t n, char_type c ) { while ( n-- ) { if ( eq(*s, c) ) return s; ++s; } return 0; } }; template <> struct nsCharTraits { typedef char char_type; typedef unsigned char unsigned_char_type; typedef PRUnichar incompatible_char_type; static void assign( char_type& lhs, char_type rhs ) { lhs = rhs; } typedef int int_type; static char_type to_char_type( int_type c ) { return char_type(c); } static int_type to_int_type( char_type c ) { return int_type( static_cast< unsigned_char_type >(c) ); } static nsCharTraits_bool eq_int_type( int_type lhs, int_type rhs ) { return lhs == rhs; } static nsCharTraits_bool eq( char_type lhs, char_type rhs ) { return lhs == rhs; } static nsCharTraits_bool lt( char_type lhs, char_type rhs ) { return lhs < rhs; } static char_type* move( char_type* s1, const char_type* s2, size_t n ) { return static_cast< char_type* >(memmove(s1, s2, n * sizeof(char_type))); } static char_type* copy( char_type* s1, const char_type* s2, size_t n ) { return static_cast< char_type* >(memcpy(s1, s2, n * sizeof(char_type))); } static char_type* assign( char_type* s, size_t n, char_type c ) { return static_cast< char_type* >(memset(s, to_int_type(c), n)); } static int compare( const char_type* s1, const char_type* s2, size_t n ) { return memcmp(s1, s2, n); } static size_t length( const char_type* s ) { return strlen(s); } static const char_type* find( const char_type* s, size_t n, char_type c ) { return reinterpret_cast< const char_type* >(memchr(s, to_int_type(c), n)); } }; template struct nsCharSourceTraits { typedef typename InputIterator::difference_type difference_type; static PRUint32 readable_distance( const InputIterator& iter ) { return iter.size_forward(); } static PRUint32 readable_distance( const InputIterator& first, const InputIterator& last ) { return PRUint32(SameFragment(first, last) ? last.get()-first.get() : first.size_forward()); } static const typename InputIterator::value_type* read( const InputIterator& iter ) { return iter.get(); } static void advance( InputIterator& s, difference_type n ) { s.advance(n); } }; template struct nsCharSourceTraits { typedef ptrdiff_t difference_type; static PRUint32 readable_distance( CharT* s ) { return PRUint32(nsCharTraits::length(s)); } static PRUint32 readable_distance( CharT* first, CharT* last ) { return PRUint32(last-first); } static const CharT* read( CharT* s ) { return s; } static void advance( CharT*& s, difference_type n ) { s += n; } }; template struct nsCharSinkTraits { static PRUint32 write( OutputIterator& iter, const typename OutputIterator::value_type* s, PRUint32 n ) { return iter.write(s, n); } }; template struct nsCharSinkTraits { static PRUint32 write( CharT*& iter, const CharT* s, PRUint32 n ) { nsCharTraits::move(iter, s, n); iter += n; return n; } }; enum nsFragmentRequest { kPrevFragment, kFirstFragment, kLastFragment, kNextFragment, kFragmentAt }; template struct nsReadableFragment { const CharT* mStart; const CharT* mEnd; const void* mFragmentIdentifier; nsReadableFragment() : mStart(0), mEnd(0), mFragmentIdentifier(0) { } const void* GetID() const { return mFragmentIdentifier; } unsigned long GetIDAsInt() const { typedef char* char_ptr; typedef unsigned long ulong; return ulong(char_ptr(mFragmentIdentifier)-char_ptr(0)); } void SetID( const void* id ) { mFragmentIdentifier = id; } void SetID( unsigned long id ) { typedef char* char_ptr; typedef void* void_ptr; mFragmentIdentifier = void_ptr(char_ptr(0)+id); } }; template struct nsWritableFragment { CharT* mStart; CharT* mEnd; void* mFragmentIdentifier; nsWritableFragment() : mStart(0), mEnd(0), mFragmentIdentifier(0) { } }; template struct nsStringTraits { typedef nsAString abstract_string_type; typedef nsAPromiseString abstract_promise_type; typedef nsAFlatString abstract_flat_type; typedef const nsDependentString literal_string_type; }; template <> struct nsStringTraits { typedef nsACString abstract_string_type; typedef nsAPromiseCString abstract_promise_type; typedef nsAFlatCString abstract_flat_type; typedef const nsDependentCString literal_string_type; }; template inline const T& NS_MIN( const T& a, const T& b ) { return b < a ? b : a; } template inline const T& NS_MAX( const T& a, const T& b ) { return a > b ? a : b; } template inline PRUint32 NS_COUNT( InputIterator& first, const InputIterator& last, const T& value ) { PRUint32 result = 0; for ( ; first != last; ++first ) if ( *first == value ) ++result; return result; } template inline OutputIterator& copy_string( InputIterator& first, const InputIterator& last, OutputIterator& result ) { typedef nsCharSourceTraits source_traits; typedef nsCharSinkTraits sink_traits; while ( first != last ) { PRInt32 count_copied = PRInt32(sink_traits::write(result, source_traits::read(first), source_traits::readable_distance(first, last))); if (!(count_copied > 0)) nsDebug::Assertion("|copy_string| will never terminate", "count_copied > 0", "../../dist/include/string/nsAlgorithm.h", 91); source_traits::advance(first, count_copied); } return result; } template OutputIterator& copy_string_backward( const InputIterator& first, InputIterator& last, OutputIterator& result ) { while ( first != last ) { last.normalize_backward(); result.normalize_backward(); PRUint32 lengthToCopy = PRUint32( NS_MIN(last.size_backward(), result.size_backward()) ); if ( first.fragment().mStart == last.fragment().mStart ) lengthToCopy = NS_MIN(lengthToCopy, PRUint32(last.get() - first.get())); if (!(lengthToCopy)) nsDebug::Assertion("|copy_string_backward| will never terminate", "lengthToCopy", "../../dist/include/string/nsAlgorithm.h", 110); nsCharTraits::move(result.get()-lengthToCopy, last.get()-lengthToCopy, lengthToCopy); last.advance( -PRInt32(lengthToCopy) ); result.advance( -PRInt32(lengthToCopy) ); } return result; } template class nsReadingIterator { public: typedef ptrdiff_t difference_type; typedef CharT value_type; typedef const CharT* pointer; typedef const CharT& reference; typedef nsReadableFragment const_fragment_type; typedef nsWritableFragment fragment_type; private: friend class nsAString; friend class nsACString; typedef typename nsStringTraits::abstract_string_type abstract_string_type; const_fragment_type mFragment; const CharT* mPosition; const abstract_string_type* mOwningString; public: nsReadingIterator() { } inline void normalize_forward(); inline void normalize_backward(); pointer get() const { return mPosition; } CharT operator*() const { return *get(); } nsReadingIterator& operator++() { ++mPosition; normalize_forward(); return *this; } nsReadingIterator operator++( int ) { nsReadingIterator result(*this); ++mPosition; normalize_forward(); return result; } nsReadingIterator& operator--() { normalize_backward(); --mPosition; return *this; } nsReadingIterator operator--( int ) { nsReadingIterator result(*this); normalize_backward(); --mPosition; return result; } const const_fragment_type& fragment() const { return mFragment; } const abstract_string_type& string() const { if (!(mOwningString)) nsDebug::Assertion("iterator not attached to a string (|mOwningString| == 0)", "mOwningString", "../../dist/include/string/nsStringIterator.h", 151); return *mOwningString; } difference_type size_forward() const { return mFragment.mEnd - mPosition; } difference_type size_backward() const { return mPosition - mFragment.mStart; } nsReadingIterator& advance( difference_type n ) { while ( n > 0 ) { difference_type one_hop = NS_MIN(n, size_forward()); if (!(one_hop>0)) nsDebug::Assertion("Infinite loop: can't advance a reading iterator beyond the end of a string", "one_hop>0", "../../dist/include/string/nsStringIterator.h", 174); mPosition += one_hop; normalize_forward(); n -= one_hop; } while ( n < 0 ) { normalize_backward(); difference_type one_hop = NS_MAX(n, -size_backward()); if (!(one_hop<0)) nsDebug::Assertion("Infinite loop: can't advance (backward) a reading iterator beyond the end of a string", "one_hop<0", "../../dist/include/string/nsStringIterator.h", 187); mPosition += one_hop; n -= one_hop; } return *this; } }; template class nsWritingIterator { public: typedef ptrdiff_t difference_type; typedef CharT value_type; typedef CharT* pointer; typedef CharT& reference; typedef nsReadableFragment const_fragment_type; typedef nsWritableFragment fragment_type; private: friend class nsAString; friend class nsACString; typedef typename nsStringTraits::abstract_string_type abstract_string_type; fragment_type mFragment; CharT* mPosition; abstract_string_type* mOwningString; public: nsWritingIterator() { } inline void normalize_forward(); inline void normalize_backward(); pointer get() const { return mPosition; } reference operator*() const { return *get(); } nsWritingIterator& operator++() { ++mPosition; normalize_forward(); return *this; } nsWritingIterator operator++( int ) { nsWritingIterator result(*this); ++mPosition; normalize_forward(); return result; } nsWritingIterator& operator--() { normalize_backward(); --mPosition; return *this; } nsWritingIterator operator--( int ) { nsWritingIterator result(*this); normalize_backward(); --mPosition; return result; } const fragment_type& fragment() const { return mFragment; } fragment_type& fragment() { return mFragment; } const abstract_string_type& string() const { if (!(mOwningString)) nsDebug::Assertion("iterator not attached to a string (|mOwningString| == 0)", "mOwningString", "../../dist/include/string/nsStringIterator.h", 300); return *mOwningString; } abstract_string_type& string() { if (!(mOwningString)) nsDebug::Assertion("iterator not attached to a string (|mOwningString| == 0)", "mOwningString", "../../dist/include/string/nsStringIterator.h", 307); return *mOwningString; } difference_type size_forward() const { return mFragment.mEnd - mPosition; } difference_type size_backward() const { return mPosition - mFragment.mStart; } nsWritingIterator& advance( difference_type n ) { while ( n > 0 ) { difference_type one_hop = NS_MIN(n, size_forward()); if (!(one_hop>0)) nsDebug::Assertion("Infinite loop: can't advance a writing iterator beyond the end of a string", "one_hop>0", "../../dist/include/string/nsStringIterator.h", 330); mPosition += one_hop; normalize_forward(); n -= one_hop; } while ( n < 0 ) { normalize_backward(); difference_type one_hop = NS_MAX(n, -size_backward()); if (!(one_hop<0)) nsDebug::Assertion("Infinite loop: can't advance (backward) a writing iterator beyond the end of a string", "one_hop<0", "../../dist/include/string/nsStringIterator.h", 343); mPosition += one_hop; n -= one_hop; } return *this; } PRUint32 write( const value_type* s, PRUint32 n ) { if (!(size_forward() > 0)) nsDebug::Assertion("You can't |write| into an |nsWritingIterator| with no space!", "size_forward() > 0", "../../dist/include/string/nsStringIterator.h", 356); n = NS_MIN(n, PRUint32(size_forward())); nsCharTraits::move(mPosition, s, n); advance( difference_type(n) ); return n; } }; template inline void nsReadingIterator::normalize_forward() { while ( mPosition == mFragment.mEnd && mOwningString->GetReadableFragment(mFragment, kNextFragment) ) mPosition = mFragment.mStart; } template inline void nsReadingIterator::normalize_backward() { while ( mPosition == mFragment.mStart && mOwningString->GetReadableFragment(mFragment, kPrevFragment) ) mPosition = mFragment.mEnd; } template inline PRBool operator==( const nsReadingIterator& lhs, const nsReadingIterator& rhs ) { return lhs.get() == rhs.get(); } template inline PRBool operator!=( const nsReadingIterator& lhs, const nsReadingIterator& rhs ) { return lhs.get() != rhs.get(); } template inline void nsWritingIterator::normalize_forward() { while ( mPosition == mFragment.mEnd && mOwningString->GetWritableFragment(mFragment, kNextFragment) ) mPosition = mFragment.mStart; } template inline void nsWritingIterator::normalize_backward() { while ( mPosition == mFragment.mStart && mOwningString->GetWritableFragment(mFragment, kPrevFragment) ) mPosition = mFragment.mEnd; } template inline PRBool operator==( const nsWritingIterator& lhs, const nsWritingIterator& rhs ) { return lhs.get() == rhs.get(); } template inline PRBool operator!=( const nsWritingIterator& lhs, const nsWritingIterator& rhs ) { return lhs.get() != rhs.get(); } class nsStringComparator { public: typedef PRUnichar char_type; virtual int operator()( const char_type*, const char_type*, PRUint32 aLength ) const = 0; virtual int operator()( char_type, char_type ) const = 0; }; class nsDefaultStringComparator : public nsStringComparator { public: virtual int operator()( const char_type*, const char_type*, PRUint32 aLength ) const; virtual int operator() ( char_type, char_type ) const; }; class nsCStringComparator { public: typedef char char_type; virtual int operator()( const char_type*, const char_type*, PRUint32 aLength ) const = 0; virtual int operator() ( char_type, char_type ) const = 0; }; class nsDefaultCStringComparator : public nsCStringComparator { public: virtual int operator()( const char_type*, const char_type*, PRUint32 aLength ) const; virtual int operator()( char_type, char_type ) const; }; class nsAString { public: typedef PRUnichar char_type; typedef char incompatible_char_type; typedef nsBufferHandle buffer_handle_type; typedef nsConstBufferHandle const_buffer_handle_type; typedef nsSharedBufferHandle shared_buffer_handle_type; typedef nsReadableFragment const_fragment_type; typedef nsWritableFragment fragment_type; typedef nsAString self_type; typedef nsAString abstract_string_type; typedef nsReadingIterator const_iterator; typedef nsWritingIterator iterator; typedef nsAPromiseString promise_type; typedef PRUint32 size_type; typedef PRUint32 index_type; public: virtual ~nsAString() { } virtual PRUint32 GetImplementationFlags() const; virtual const buffer_handle_type* GetFlatBufferHandle() const; virtual const buffer_handle_type* GetBufferHandle() const; virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; inline const_iterator& BeginReading( const_iterator& ) const; inline const_iterator& EndReading( const_iterator& ) const; inline iterator& BeginWriting( iterator& ); inline iterator& EndWriting( iterator& ); virtual size_type Length() const = 0; PRBool IsEmpty() const { return Length() == 0; } inline PRBool Equals( const abstract_string_type&, const nsStringComparator& = nsDefaultStringComparator() ) const; PRBool Equals( const char_type*, const nsStringComparator& = nsDefaultStringComparator() ) const; virtual PRBool IsVoid() const; virtual void SetIsVoid( PRBool ); char_type First() const; char_type Last() const; size_type CountChar( char_type ) const; size_type Left( self_type&, size_type ) const; size_type Mid( self_type&, PRUint32, PRUint32 ) const; size_type Right( self_type&, size_type ) const; PRInt32 FindChar( char_type, index_type aOffset = 0 ) const; virtual void SetCapacity( size_type ) { } virtual void SetLength( size_type ) { } void Truncate( size_type aNewLength=0 ) { if (!(aNewLength <= this->Length())) nsDebug::Assertion("Can't use |Truncate()| to make a string longer.", "aNewLength <= this->Length()", "../../dist/include/string/nsAString.h", 230); SetLength(aNewLength); } void Assign( const self_type& aReadable ) { AssignFromReadable(aReadable); } inline void Assign( const promise_type& aReadable ); void Assign( const char_type* aPtr ) { aPtr ? do_AssignFromElementPtr(aPtr) : SetLength(0); } void Assign( const char_type* aPtr, size_type aLength ) { do_AssignFromElementPtrLength(aPtr, aLength); } void Assign( char_type aChar ) { do_AssignFromElement(aChar); } self_type& operator=( const self_type& aReadable ) { Assign(aReadable); return *this; } self_type& operator=( const promise_type& aReadable ) { Assign(aReadable); return *this; } self_type& operator=( const char_type* aPtr ) { Assign(aPtr); return *this; } self_type& operator=( char_type aChar ) { Assign(aChar); return *this; } void Append( const self_type& aReadable ) { AppendFromReadable(aReadable); } inline void Append( const promise_type& aReadable ); void Append( const char_type* aPtr ) { if (aPtr) do_AppendFromElementPtr(aPtr); } void Append( const char_type* aPtr, size_type aLength ) { do_AppendFromElementPtrLength(aPtr, aLength); } void Append( char_type aChar ) { do_AppendFromElement(aChar); } self_type& operator+=( const self_type& aReadable ) { Append(aReadable); return *this; } self_type& operator+=( const promise_type& aReadable ) { Append(aReadable); return *this; } self_type& operator+=( const char_type* aPtr ) { Append(aPtr); return *this; } self_type& operator+=( char_type aChar ) { Append(aChar); return *this; } void Insert( const self_type& aReadable, index_type atPosition ) { InsertFromReadable(aReadable, atPosition); } inline void Insert( const promise_type& aReadable, index_type atPosition ); void Insert( const char_type* aPtr, index_type atPosition ) { if (aPtr) do_InsertFromElementPtr(aPtr, atPosition); } void Insert( const char_type* aPtr, index_type atPosition, size_type aLength ) { do_InsertFromElementPtrLength(aPtr, atPosition, aLength); } void Insert( char_type aChar, index_type atPosition ) { do_InsertFromElement(aChar, atPosition); } virtual void Cut( index_type cutStart, size_type cutLength ); void Replace( index_type cutStart, size_type cutLength, const self_type& aReadable ) { ReplaceFromReadable(cutStart, cutLength, aReadable); } private: index_type CountChar( incompatible_char_type ) const; void operator= ( incompatible_char_type ); void Assign ( incompatible_char_type ); void operator+= ( incompatible_char_type ); void Append ( incompatible_char_type ); void Insert ( incompatible_char_type, index_type ); protected: void AssignFromReadable( const self_type& ); void AssignFromPromise( const self_type& ); virtual void do_AssignFromReadable( const self_type& ); virtual void do_AssignFromElementPtr( const char_type* ); virtual void do_AssignFromElementPtrLength( const char_type*, size_type ); virtual void do_AssignFromElement( char_type ); void AppendFromReadable( const self_type& ); void AppendFromPromise( const self_type& ); virtual void do_AppendFromReadable( const self_type& ); virtual void do_AppendFromElementPtr( const char_type* ); virtual void do_AppendFromElementPtrLength( const char_type*, size_type ); virtual void do_AppendFromElement( char_type ); void InsertFromReadable( const self_type&, index_type ); void InsertFromPromise( const self_type&, index_type ); virtual void do_InsertFromReadable( const self_type&, index_type ); virtual void do_InsertFromElementPtr( const char_type*, index_type ); virtual void do_InsertFromElementPtrLength( const char_type*, index_type, size_type ); virtual void do_InsertFromElement( char_type, index_type ); void ReplaceFromReadable( index_type, size_type, const self_type& ); void ReplaceFromPromise( index_type, size_type, const self_type& ); virtual void do_ReplaceFromReadable( index_type, size_type, const self_type& ); public: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 = 0 ) const = 0; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 = 0 ) = 0; virtual PRBool IsDependentOn( const self_type& aString ) const { return &aString == this; } }; class nsACString { public: typedef char char_type; typedef PRUnichar incompatible_char_type; typedef nsBufferHandle buffer_handle_type; typedef nsConstBufferHandle const_buffer_handle_type; typedef nsSharedBufferHandle shared_buffer_handle_type; typedef nsReadableFragment const_fragment_type; typedef nsWritableFragment fragment_type; typedef nsACString self_type; typedef nsACString abstract_string_type; typedef nsReadingIterator const_iterator; typedef nsWritingIterator iterator; typedef nsAPromiseCString promise_type; typedef PRUint32 size_type; typedef PRUint32 index_type; virtual ~nsACString() { } virtual PRUint32 GetImplementationFlags() const; virtual const buffer_handle_type* GetFlatBufferHandle() const; virtual const buffer_handle_type* GetBufferHandle() const; virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; inline const_iterator& BeginReading( const_iterator& ) const; inline const_iterator& EndReading( const_iterator& ) const; inline iterator& BeginWriting( iterator& ); inline iterator& EndWriting( iterator& ); virtual size_type Length() const = 0; PRBool IsEmpty() const { return Length() == 0; } inline PRBool Equals( const abstract_string_type&, const nsCStringComparator& = nsDefaultCStringComparator() ) const; PRBool Equals( const char_type*, const nsCStringComparator& = nsDefaultCStringComparator() ) const; virtual PRBool IsVoid() const; virtual void SetIsVoid( PRBool ); char_type First() const; char_type Last() const; size_type CountChar( char_type ) const; size_type Left( self_type&, size_type ) const; size_type Mid( self_type&, PRUint32, PRUint32 ) const; size_type Right( self_type&, size_type ) const; PRInt32 FindChar( char_type, index_type aOffset = 0 ) const; virtual void SetCapacity( size_type ) { } virtual void SetLength( size_type ) { } void Truncate( size_type aNewLength=0 ) { if (!(aNewLength <= this->Length())) nsDebug::Assertion("Can't use |Truncate()| to make a string longer.", "aNewLength <= this->Length()", "../../dist/include/string/nsAString.h", 505); SetLength(aNewLength); } void Assign( const self_type& aReadable ) { AssignFromReadable(aReadable); } inline void Assign( const promise_type& aReadable ); void Assign( const char_type* aPtr ) { aPtr ? do_AssignFromElementPtr(aPtr) : SetLength(0); } void Assign( const char_type* aPtr, size_type aLength ) { do_AssignFromElementPtrLength(aPtr, aLength); } void Assign( char_type aChar ) { do_AssignFromElement(aChar); } self_type& operator=( const self_type& aReadable ) { Assign(aReadable); return *this; } self_type& operator=( const promise_type& aReadable ) { Assign(aReadable); return *this; } self_type& operator=( const char_type* aPtr ) { Assign(aPtr); return *this; } self_type& operator=( char_type aChar ) { Assign(aChar); return *this; } void Append( const self_type& aReadable ) { AppendFromReadable(aReadable); } inline void Append( const promise_type& aReadable ); void Append( const char_type* aPtr ) { if (aPtr) do_AppendFromElementPtr(aPtr); } void Append( const char_type* aPtr, size_type aLength ) { do_AppendFromElementPtrLength(aPtr, aLength); } void Append( char_type aChar ) { do_AppendFromElement(aChar); } self_type& operator+=( const self_type& aReadable ) { Append(aReadable); return *this; } self_type& operator+=( const promise_type& aReadable ) { Append(aReadable); return *this; } self_type& operator+=( const char_type* aPtr ) { Append(aPtr); return *this; } self_type& operator+=( char_type aChar ) { Append(aChar); return *this; } void Insert( const self_type& aReadable, index_type atPosition ) { InsertFromReadable(aReadable, atPosition); } inline void Insert( const promise_type& aReadable, index_type atPosition ); void Insert( const char_type* aPtr, index_type atPosition ) { if (aPtr) do_InsertFromElementPtr(aPtr, atPosition); } void Insert( const char_type* aPtr, index_type atPosition, size_type aLength ) { do_InsertFromElementPtrLength(aPtr, atPosition, aLength); } void Insert( char_type aChar, index_type atPosition ) { do_InsertFromElement(aChar, atPosition); } virtual void Cut( index_type cutStart, size_type cutLength ); void Replace( index_type cutStart, size_type cutLength, const self_type& aReadable ) { ReplaceFromReadable(cutStart, cutLength, aReadable); } private: index_type CountChar( incompatible_char_type ) const; void operator= ( incompatible_char_type ); void Assign ( incompatible_char_type ); void operator+= ( incompatible_char_type ); void Append ( incompatible_char_type ); void Insert ( incompatible_char_type, index_type ); protected: void AssignFromReadable( const self_type& ); void AssignFromPromise( const self_type& ); virtual void do_AssignFromReadable( const self_type& ); virtual void do_AssignFromElementPtr( const char_type* ); virtual void do_AssignFromElementPtrLength( const char_type*, size_type ); virtual void do_AssignFromElement( char_type ); void AppendFromReadable( const self_type& ); void AppendFromPromise( const self_type& ); virtual void do_AppendFromReadable( const self_type& ); virtual void do_AppendFromElementPtr( const char_type* ); virtual void do_AppendFromElementPtrLength( const char_type*, size_type ); virtual void do_AppendFromElement( char_type ); void InsertFromReadable( const self_type&, index_type ); void InsertFromPromise( const self_type&, index_type ); virtual void do_InsertFromReadable( const self_type&, index_type ); virtual void do_InsertFromElementPtr( const char_type*, index_type ); virtual void do_InsertFromElementPtrLength( const char_type*, index_type, size_type ); virtual void do_InsertFromElement( char_type, index_type ); void ReplaceFromReadable( index_type, size_type, const self_type& ); void ReplaceFromPromise( index_type, size_type, const self_type& ); virtual void do_ReplaceFromReadable( index_type, size_type, const self_type& ); public: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 = 0 ) const = 0; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 = 0 ) = 0; virtual PRBool IsDependentOn( const self_type& aString ) const { return &aString == this; } }; class nsAPromiseString : public nsAString { }; class nsAPromiseCString : public nsACString { }; inline void nsAString::Assign( const nsAPromiseString& aReadable ) { AssignFromPromise(aReadable); } inline void nsAString::Append( const nsAPromiseString& aReadable ) { AppendFromPromise(aReadable); } inline void nsAString::Insert( const nsAPromiseString& aReadable, index_type atPosition ) { InsertFromPromise(aReadable, atPosition); } inline void nsACString::Assign( const nsAPromiseCString& aReadable ) { AssignFromPromise(aReadable); } inline void nsACString::Append( const nsAPromiseCString& aReadable ) { AppendFromPromise(aReadable); } inline void nsACString::Insert( const nsAPromiseCString& aReadable, index_type atPosition ) { InsertFromPromise(aReadable, atPosition); } inline nsAString::const_iterator& nsAString::BeginReading( const_iterator& aResult ) const { aResult.mOwningString = this; GetReadableFragment(aResult.mFragment, kFirstFragment); aResult.mPosition = aResult.mFragment.mStart; aResult.normalize_forward(); return aResult; } inline nsAString::const_iterator& nsAString::EndReading( const_iterator& aResult ) const { aResult.mOwningString = this; GetReadableFragment(aResult.mFragment, kLastFragment); aResult.mPosition = aResult.mFragment.mEnd; return aResult; } inline nsAString::iterator& nsAString::BeginWriting( iterator& aResult ) { aResult.mOwningString = this; GetWritableFragment(aResult.mFragment, kFirstFragment); aResult.mPosition = aResult.mFragment.mStart; aResult.normalize_forward(); return aResult; } inline nsAString::iterator& nsAString::EndWriting( iterator& aResult ) { aResult.mOwningString = this; GetWritableFragment(aResult.mFragment, kLastFragment); aResult.mPosition = aResult.mFragment.mEnd; return aResult; } int Compare( const nsAString& lhs, const nsAString& rhs, const nsStringComparator& = nsDefaultStringComparator() ); inline PRBool nsAString::Equals( const abstract_string_type& rhs, const nsStringComparator& aComparator ) const { return Length()==rhs.Length() && Compare(*this, rhs, aComparator)==0; } inline PRBool operator!=( const nsAString& lhs, const nsAString& rhs ) { return !lhs.Equals(rhs); } inline PRBool operator< ( const nsAString& lhs, const nsAString& rhs ) { return Compare(lhs, rhs)< 0; } inline PRBool operator<=( const nsAString& lhs, const nsAString& rhs ) { return Compare(lhs, rhs)<=0; } inline PRBool operator==( const nsAString& lhs, const nsAString& rhs ) { return lhs.Equals(rhs); } inline PRBool operator>=( const nsAString& lhs, const nsAString& rhs ) { return Compare(lhs, rhs)>=0; } inline PRBool operator> ( const nsAString& lhs, const nsAString& rhs ) { return Compare(lhs, rhs)> 0; } inline nsAString::size_type nsAString::Left( nsAString& aResult, size_type aLengthToCopy ) const { return Mid(aResult, 0, aLengthToCopy); } inline nsACString::const_iterator& nsACString::BeginReading( const_iterator& aResult ) const { aResult.mOwningString = this; GetReadableFragment(aResult.mFragment, kFirstFragment); aResult.mPosition = aResult.mFragment.mStart; aResult.normalize_forward(); return aResult; } inline nsACString::const_iterator& nsACString::EndReading( const_iterator& aResult ) const { aResult.mOwningString = this; GetReadableFragment(aResult.mFragment, kLastFragment); aResult.mPosition = aResult.mFragment.mEnd; return aResult; } inline nsACString::iterator& nsACString::BeginWriting( iterator& aResult ) { aResult.mOwningString = this; GetWritableFragment(aResult.mFragment, kFirstFragment); aResult.mPosition = aResult.mFragment.mStart; aResult.normalize_forward(); return aResult; } inline nsACString::iterator& nsACString::EndWriting( iterator& aResult ) { aResult.mOwningString = this; GetWritableFragment(aResult.mFragment, kLastFragment); aResult.mPosition = aResult.mFragment.mEnd; return aResult; } class nsCaseInsensitiveCStringComparator : public nsCStringComparator { public: virtual int operator()( const char_type*, const char_type*, PRUint32 aLength ) const; virtual int operator()( char_type, char_type ) const; }; int Compare( const nsACString& lhs, const nsACString& rhs, const nsCStringComparator& = nsDefaultCStringComparator() ); inline PRBool nsACString::Equals( const abstract_string_type& rhs, const nsCStringComparator& aComparator ) const { return Length()==rhs.Length() && Compare(*this, rhs, aComparator)==0; } inline PRBool operator!=( const nsACString& lhs, const nsACString& rhs ) { return !lhs.Equals(rhs); } inline PRBool operator< ( const nsACString& lhs, const nsACString& rhs ) { return Compare(lhs, rhs)< 0; } inline PRBool operator<=( const nsACString& lhs, const nsACString& rhs ) { return Compare(lhs, rhs)<=0; } inline PRBool operator==( const nsACString& lhs, const nsACString& rhs ) { return lhs.Equals(rhs); } inline PRBool operator>=( const nsACString& lhs, const nsACString& rhs ) { return Compare(lhs, rhs)>=0; } inline PRBool operator> ( const nsACString& lhs, const nsACString& rhs ) { return Compare(lhs, rhs)> 0; } inline nsACString::size_type nsACString::Left( nsACString& aResult, size_type aLengthToCopy ) const { return Mid(aResult, 0, aLengthToCopy); } class nsDependentConcatenation : public nsAPromiseString { public: typedef nsDependentConcatenation self_type; protected: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ) { return 0; } enum { kFirstString, kLastString }; int GetCurrentStringFromFragment( const const_fragment_type& aFragment ) const { return (aFragment.GetIDAsInt() & mFragmentIdentifierMask) ? kLastString : kFirstString; } int SetFirstStringInFragment( const_fragment_type& aFragment ) const { aFragment.SetID(aFragment.GetIDAsInt() & ~mFragmentIdentifierMask); return kFirstString; } int SetLastStringInFragment( const_fragment_type& aFragment ) const { aFragment.SetID(aFragment.GetIDAsInt() | mFragmentIdentifierMask); return kLastString; } public: nsDependentConcatenation( const abstract_string_type& aFirstString, const abstract_string_type& aLastString, PRUint32 aMask = 1 ) : mFragmentIdentifierMask(aMask) { mStrings[kFirstString] = &aFirstString; mStrings[kLastString] = &aLastString; } nsDependentConcatenation( const self_type& aFirstString, const abstract_string_type& aLastString ) : mFragmentIdentifierMask(aFirstString.mFragmentIdentifierMask<<1) { mStrings[kFirstString] = &aFirstString; mStrings[kLastString] = &aLastString; } private: void operator=( const self_type& ); public: virtual PRUint32 Length() const; virtual PRBool IsDependentOn( const abstract_string_type& ) const; PRUint32 GetFragmentIdentifierMask() const { return mFragmentIdentifierMask; } private: void operator+( const self_type& ); private: const abstract_string_type* mStrings[2]; PRUint32 mFragmentIdentifierMask; }; class nsDependentCConcatenation : public nsAPromiseCString { public: typedef nsDependentCConcatenation self_type; protected: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ) { return 0; } enum { kFirstString, kLastString }; int GetCurrentStringFromFragment( const const_fragment_type& aFragment ) const { return (aFragment.GetIDAsInt() & mFragmentIdentifierMask) ? kLastString : kFirstString; } int SetFirstStringInFragment( const_fragment_type& aFragment ) const { aFragment.SetID(aFragment.GetIDAsInt() & ~mFragmentIdentifierMask); return kFirstString; } int SetLastStringInFragment( const_fragment_type& aFragment ) const { aFragment.SetID(aFragment.GetIDAsInt() | mFragmentIdentifierMask); return kLastString; } public: nsDependentCConcatenation( const abstract_string_type& aFirstString, const abstract_string_type& aLastString, PRUint32 aMask = 1 ) : mFragmentIdentifierMask(aMask) { mStrings[kFirstString] = &aFirstString; mStrings[kLastString] = &aLastString; } nsDependentCConcatenation( const self_type& aFirstString, const abstract_string_type& aLastString ) : mFragmentIdentifierMask(aFirstString.mFragmentIdentifierMask<<1) { mStrings[kFirstString] = &aFirstString; mStrings[kLastString] = &aLastString; } private: void operator=( const self_type& ); public: virtual PRUint32 Length() const; virtual PRBool IsDependentOn( const abstract_string_type& ) const; PRUint32 GetFragmentIdentifierMask() const { return mFragmentIdentifierMask; } private: void operator+( const self_type& ); private: const abstract_string_type* mStrings[2]; PRUint32 mFragmentIdentifierMask; }; inline const nsDependentConcatenation operator+( const nsDependentConcatenation& lhs, const nsAString& rhs ) { return nsDependentConcatenation(lhs, rhs, lhs.GetFragmentIdentifierMask()<<1); } inline const nsDependentCConcatenation operator+( const nsDependentCConcatenation& lhs, const nsACString& rhs ) { return nsDependentCConcatenation(lhs, rhs, lhs.GetFragmentIdentifierMask()<<1); } inline const nsDependentConcatenation operator+( const nsAString& lhs, const nsAString& rhs ) { return nsDependentConcatenation(lhs, rhs); } inline const nsDependentCConcatenation operator+( const nsACString& lhs, const nsACString& rhs ) { return nsDependentCConcatenation(lhs, rhs); } class nsASingleFragmentString : public nsAString { public: typedef const char_type* const_char_iterator; typedef char_type* char_iterator; using abstract_string_type::BeginReading; using abstract_string_type::EndReading; using abstract_string_type::BeginWriting; using abstract_string_type::EndWriting; inline const_char_iterator& BeginReading( const_char_iterator& aResult ) const { const_fragment_type f; GetReadableFragment(f, kFirstFragment, 0); return aResult = f.mStart; } inline const_char_iterator& EndReading( const_char_iterator& aResult ) const { const_fragment_type f; GetReadableFragment(f, kLastFragment, 0); return aResult = f.mEnd; } inline char_iterator& BeginWriting( char_iterator& aResult ) { fragment_type f; GetWritableFragment(f, kFirstFragment, 0); return aResult = const_cast< char_iterator >(f.mStart); } inline char_iterator& EndWriting( char_iterator& aResult ) { fragment_type f; GetWritableFragment(f, kLastFragment, 0); return aResult = const_cast< char_iterator >(f.mEnd); } char_type operator[]( PRUint32 i ) const { const_char_iterator temp; return BeginReading(temp)[ i ]; } char_type CharAt( PRUint32 ) const; virtual PRUint32 Length() const; public: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ); }; class nsASingleFragmentCString : public nsACString { public: typedef const char_type* const_char_iterator; typedef char_type* char_iterator; using abstract_string_type::BeginReading; using abstract_string_type::EndReading; using abstract_string_type::BeginWriting; using abstract_string_type::EndWriting; inline const_char_iterator& BeginReading( const_char_iterator& aResult ) const { const_fragment_type f; GetReadableFragment(f, kFirstFragment, 0); return aResult = f.mStart; } inline const_char_iterator& EndReading( const_char_iterator& aResult ) const { const_fragment_type f; GetReadableFragment(f, kLastFragment, 0); return aResult = f.mEnd; } inline char_iterator& BeginWriting( char_iterator& aResult ) { fragment_type f; GetWritableFragment(f, kFirstFragment, 0); return aResult = const_cast< char_iterator >(f.mStart); } inline char_iterator& EndWriting( char_iterator& aResult ) { fragment_type f; GetWritableFragment(f, kLastFragment, 0); return aResult = const_cast< char_iterator >(f.mEnd); } char_type operator[]( PRUint32 i ) const { const_char_iterator temp; return BeginReading(temp)[ i ]; } char_type CharAt( PRUint32 ) const; virtual PRUint32 Length() const; public: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ); }; inline nsASingleFragmentString::char_type nsASingleFragmentString::CharAt( PRUint32 i ) const { if (!(i class nsAutoBufferHandle { public: nsAutoBufferHandle() : mHandle(0) { } nsAutoBufferHandle( const nsAutoBufferHandle& aOther ) : mHandle(aOther.get()) { if ( mHandle ) mHandle->AcquireReference(); } explicit nsAutoBufferHandle( const nsSharedBufferHandle* aHandle ) : mHandle( const_cast< nsSharedBufferHandle* >(aHandle) ) { if ( mHandle ) mHandle->AcquireReference(); } ~nsAutoBufferHandle() { if ( mHandle ) mHandle->ReleaseReference(); } nsAutoBufferHandle& operator=( const nsSharedBufferHandle* rhs ) { nsSharedBufferHandle* old_handle = mHandle; if ( (mHandle = const_cast< nsSharedBufferHandle* >(rhs)) ) mHandle->AcquireReference(); if ( old_handle ) old_handle->ReleaseReference(); return *this; } nsAutoBufferHandle& operator=( const nsAutoBufferHandle& rhs ) { return operator=(rhs.get()); } nsSharedBufferHandle* get() const { return mHandle; } operator nsSharedBufferHandle*() const { return get(); } nsSharedBufferHandle* operator->() const { return get(); } private: nsSharedBufferHandle* mHandle; }; template inline size_t NS_AlignedHandleSize( const HandleT*, const CharT* ) { return ((sizeof(HandleT) + sizeof(CharT) - 1) / sizeof(CharT)) * sizeof(CharT); } template inline const CharT* NS_DataAfterHandle( const HandleT* aHandlePtr, const CharT* aDummyCharTPtr ) { typedef const CharT* CharT_ptr; return CharT_ptr(static_cast< const unsigned char* >(aHandlePtr) + NS_AlignedHandleSize(aHandlePtr, aDummyCharTPtr)); } template inline CharT* NS_DataAfterHandle( HandleT* aHandlePtr, const CharT* aDummyCharTPtr ) { typedef CharT* CharT_ptr; return CharT_ptr(static_cast< unsigned char* >(aHandlePtr) + NS_AlignedHandleSize(aHandlePtr, aDummyCharTPtr)); } template HandleT* NS_AllocateContiguousHandleWithData( const HandleT* aDummyHandlePtr, PRUint32 aAdditionalCapacity, const StringT* aDataSource ) { typedef typename StringT::char_type char_type; typedef char_type* char_ptr; size_t handle_size = NS_AlignedHandleSize(aDummyHandlePtr, char_ptr(0)); size_t data_length = aDataSource? aDataSource->Length() : 0; size_t buffer_length = data_length + aAdditionalCapacity; size_t buffer_size = buffer_length * sizeof(char_type); HandleT* result = 0; void* handle_ptr = ::operator new(handle_size + buffer_size); if ( handle_ptr ) { char_ptr data_start_ptr = char_ptr(static_cast< unsigned char* >(handle_ptr) + handle_size); char_ptr data_end_ptr = data_start_ptr + data_length; char_ptr buffer_end_ptr = data_start_ptr + buffer_length; char_ptr toBegin = data_start_ptr; if ( data_length ) { typename StringT::const_iterator fromBegin, fromEnd; copy_string(aDataSource->BeginReading(fromBegin), aDataSource->EndReading(fromEnd), toBegin); } if ( aAdditionalCapacity > 0 ) *toBegin = char_type(0); result = new (handle_ptr) HandleT(data_start_ptr, data_end_ptr, buffer_end_ptr - data_start_ptr, 1); } return result; } template inline HandleT* NS_AllocateContiguousHandleWithData( const HandleT* aDummyHandlePtr, const StringT& aDataSource, PRUint32 aAdditionalCapacity ) { return NS_AllocateContiguousHandleWithData(aDummyHandlePtr, aAdditionalCapacity, &aDataSource); } class nsSharableString : public nsAFlatString { public: typedef nsSharableString self_type; public: nsSharableString() : mBuffer(GetSharedEmptyBufferHandle()) { } nsSharableString( const self_type& aOther ) : mBuffer(aOther.mBuffer) { } explicit nsSharableString( const abstract_string_type& aReadable ) { do_AssignFromReadable(aReadable); } explicit nsSharableString( const shared_buffer_handle_type* aHandle ) : mBuffer(aHandle) { if (!(aHandle)) nsDebug::Assertion("null handle", "aHandle", "../../dist/include/string/nsSharableString.h", 65); } self_type& operator=( const abstract_string_type& aReadable ) { Assign(aReadable); return *this; } void Adopt( char_type* aNewValue ); public: virtual void SetCapacity( size_type aNewCapacity ); virtual void SetLength( size_type aNewLength ); protected: virtual void do_AssignFromReadable( const abstract_string_type& aReadable ); virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; public: virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ); protected: static shared_buffer_handle_type* GetSharedEmptyBufferHandle(); protected: nsAutoBufferHandle mBuffer; }; class nsSharableCString : public nsAFlatCString { public: typedef nsSharableCString self_type; public: nsSharableCString() : mBuffer(GetSharedEmptyBufferHandle()) { } nsSharableCString( const self_type& aOther ) : mBuffer(aOther.mBuffer) { } explicit nsSharableCString( const abstract_string_type& aReadable ) { do_AssignFromReadable(aReadable); } explicit nsSharableCString( const shared_buffer_handle_type* aHandle ) : mBuffer(aHandle) { if (!(aHandle)) nsDebug::Assertion("null handle", "aHandle", "../../dist/include/string/nsSharableString.h", 127); } self_type& operator=( const abstract_string_type& aReadable ) { Assign(aReadable); return *this; } void Adopt( char_type* aNewValue ); public: virtual void SetCapacity( size_type aNewCapacity ); virtual void SetLength( size_type aNewLength ); protected: virtual void do_AssignFromReadable( const abstract_string_type& aReadable ); virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; public: virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ); protected: static shared_buffer_handle_type* GetSharedEmptyBufferHandle(); protected: nsAutoBufferHandle mBuffer; }; class nsXPIDLString : public nsSharableString { public: typedef nsXPIDLString self_type; public: nsXPIDLString() : nsSharableString(GetSharedEmptyBufferHandle()) { } nsXPIDLString( const self_type& aString ) : nsSharableString(aString.mBuffer.get()) { } explicit nsXPIDLString( const abstract_string_type& aReadable ) : nsSharableString(aReadable) { } self_type& operator=( const abstract_string_type& aReadable ) { Assign(aReadable); return *this; } void Adopt( char_type* aNewValue ) { *PrepareForUseAsOutParam() = aNewValue; } virtual const char_type* get() const { return (mBuffer.get() != GetSharedEmptyBufferHandle()) ? mBuffer->DataStart() : 0; } operator const char_type*() const { return get(); } char_type operator[]( int i ) const { return get()[ i ]; } class getter_Copies_t { public: getter_Copies_t( nsXPIDLString& aString ) : mString(&aString) { } operator char_type**() const { return mString->PrepareForUseAsOutParam(); } private: nsXPIDLString* mString; }; friend class getter_Copies_t; protected: virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; char_type** PrepareForUseAsOutParam(); static shared_buffer_handle_type* GetSharedEmptyBufferHandle(); }; inline nsXPIDLString::getter_Copies_t getter_Copies( nsXPIDLString& aString ) { return nsXPIDLString::getter_Copies_t(aString); } class nsXPIDLCString : public nsSharableCString { public: typedef nsXPIDLCString self_type; public: nsXPIDLCString() : nsSharableCString(GetSharedEmptyBufferHandle()) { } nsXPIDLCString( const self_type& aString ) : nsSharableCString(aString.mBuffer.get()) { } self_type& operator=( const abstract_string_type& aReadable ) { Assign(aReadable); return *this; } void Adopt( char_type* aNewValue ) { *PrepareForUseAsOutParam() = aNewValue; } virtual const char_type* get() const { return (mBuffer.get() != GetSharedEmptyBufferHandle()) ? mBuffer->DataStart() : 0; } operator const char_type*() const { return get(); } char_type operator[]( int i ) const { return get()[ i ]; } class getter_Copies_t { public: getter_Copies_t( nsXPIDLCString& aString ) : mString(&aString) { } operator char_type**() const { return mString->PrepareForUseAsOutParam(); } private: nsXPIDLCString* mString; }; friend class getter_Copies_t; protected: virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; char_type** PrepareForUseAsOutParam(); static shared_buffer_handle_type* GetSharedEmptyBufferHandle(); }; inline nsXPIDLCString::getter_Copies_t getter_Copies( nsXPIDLCString& aString ) { return nsXPIDLCString::getter_Copies_t(aString); } typedef void (*nr_RegPackCallbackFunc) (void *userData, int32 bytes, int32 totalBytes); typedef int32 REGERR; typedef int32 RKEY; typedef uint32 REGENUM; typedef void * HREG; typedef struct _reginfo { uint16 size; uint16 entryType; uint32 entryLength; } REGINFO; extern "C" { int NR_RegSetBufferSize( HREG hReg, int bufsize ); REGERR NR_RegOpen( char *filename, HREG *hReg ); REGERR NR_RegClose( HREG hReg ); REGERR NR_RegFlush( HREG hReg ); REGERR NR_RegIsWritable( HREG hReg ); REGERR NR_RegPack( HREG hReg, void *userData, nr_RegPackCallbackFunc fn ); REGERR NR_RegSetUsername( const char *name ); REGERR NR_RegGetUniqueName( HREG hReg, char* outbuf, uint32 buflen ); REGERR NR_RegGetUsername( char **name ); REGERR NR_RegAddKey( HREG hReg, RKEY key, char *path, RKEY *newKey ); REGERR NR_RegAddKeyRaw( HREG hReg, RKEY key, char *keyname, RKEY *newKey ); REGERR NR_RegDeleteKey( HREG hReg, RKEY key, char *path ); REGERR NR_RegDeleteKeyRaw( HREG hReg, RKEY key, char *keyname ); REGERR NR_RegGetKey( HREG hReg, RKEY key, char *path, RKEY *result ); REGERR NR_RegGetKeyRaw( HREG hReg, RKEY key, char *keyname, RKEY *result ); REGERR NR_RegEnumSubkeys( HREG hReg, RKEY key, REGENUM *state, char *buffer, uint32 bufsize, uint32 style ); REGERR NR_RegGetEntryInfo( HREG hReg, RKEY key, char *name, REGINFO *info ); REGERR NR_RegGetEntryString( HREG hReg, RKEY key, char *name, char *buffer, uint32 bufsize ); REGERR NR_RegGetEntry( HREG hReg, RKEY key, char *name, void *buffer, uint32 *size ); REGERR NR_RegSetEntryString( HREG hReg, RKEY key, char *name, char *buffer ); REGERR NR_RegSetEntry( HREG hReg, RKEY key, char *name, uint16 type, void *buffer, uint32 size ); REGERR NR_RegDeleteEntry( HREG hReg, RKEY key, char *name ); REGERR NR_RegEnumEntries( HREG hReg, RKEY key, REGENUM *state, char *buffer, uint32 bufsize, REGINFO *info ); void NR_ShutdownRegistry(void); REGERR NR_StartupRegistry(void); } typedef struct _version { int32 major; int32 minor; int32 release; int32 build; int32 check; } VERSION; extern "C" { REGERR VR_CreateRegistry(char *installation, char *programPath, char *versionStr); REGERR VR_SetRegDirectory(const char *path); REGERR VR_PackRegistry(void *userData, nr_RegPackCallbackFunc pdCallbackFunction); REGERR VR_Close(void); REGERR VR_Install(char *component_path, char *filepath, char *version, int bDirectory); REGERR VR_Remove(char *component_path); REGERR VR_InRegistry(char *path); REGERR VR_ValidateComponent(char *path); REGERR VR_Enum(char *component_path, REGENUM *state, char *buffer, uint32 buflen); REGERR VR_GetVersion(char *component_path, VERSION *result); REGERR VR_GetPath(char *component_path, uint32 sizebuf, char *buf); REGERR VR_SetRefCount(char *component_path, int refcount); REGERR VR_GetRefCount(char *component_path, int *result); REGERR VR_GetDefaultDirectory(char *component_path, uint32 sizebuf, char *buf); REGERR VR_SetDefaultDirectory(char *component_path, char *directory); REGERR VR_UninstallCreateNode(char *regPackageName, char *userPackageName); REGERR VR_UninstallAddFileToList(char *regPackageName, char *vrName); REGERR VR_UninstallFileExistsInList(char *regPackageName, char *vrName); REGERR VR_UninstallEnumSharedFiles(char *component_path, REGENUM *state, char *buffer, uint32 buflen); REGERR VR_UninstallDeleteFileFromList(char *component_path, char *vrName); REGERR VR_UninstallDeleteSharedFilesKey(char *regPackageName); REGERR VR_UninstallDestroy(char *regPackageName); REGERR VR_EnumUninstall(REGENUM *state, char* userPackageName, int32 len1, char*regPackageName, int32 len2, PRBool bSharedList); REGERR VR_GetUninstallUserName(char *regPackageName, char *outbuf, uint32 buflen); } class nsISimpleEnumerator; class nsIFile : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xc8c0a080, 0x0868, 0x11d3, { 0x91, 0x5f, 0xd9, 0xd8, 0x89, 0xd4, 0x8e, 0x3c }}; return iid;} enum { NORMAL_FILE_TYPE = 0U }; enum { DIRECTORY_TYPE = 1U }; virtual nsresult Append(const char *node) = 0; virtual nsresult AppendUnicode(const PRUnichar *node) = 0; virtual nsresult Normalize(void) = 0; virtual nsresult Create(PRUint32 type, PRUint32 permissions) = 0; virtual nsresult GetLeafName(char * *aLeafName) = 0; virtual nsresult SetLeafName(const char * aLeafName) = 0; virtual nsresult GetUnicodeLeafName(PRUnichar * *aUnicodeLeafName) = 0; virtual nsresult SetUnicodeLeafName(const PRUnichar * aUnicodeLeafName) = 0; virtual nsresult CopyTo(nsIFile *newParentDir, const char *newName) = 0; virtual nsresult CopyToUnicode(nsIFile *newParentDir, const PRUnichar *newName) = 0; virtual nsresult CopyToFollowingLinks(nsIFile *newParentDir, const char *newName) = 0; virtual nsresult CopyToFollowingLinksUnicode(nsIFile *newParentDir, const PRUnichar *newName) = 0; virtual nsresult MoveTo(nsIFile *newParentDir, const char *newName) = 0; virtual nsresult MoveToUnicode(nsIFile *newParentDir, const PRUnichar *newName) = 0; virtual nsresult Remove(PRBool recursive) = 0; virtual nsresult GetPermissions(PRUint32 *aPermissions) = 0; virtual nsresult SetPermissions(PRUint32 aPermissions) = 0; virtual nsresult GetPermissionsOfLink(PRUint32 *aPermissionsOfLink) = 0; virtual nsresult SetPermissionsOfLink(PRUint32 aPermissionsOfLink) = 0; virtual nsresult GetLastModifiedTime(PRInt64 *aLastModifiedTime) = 0; virtual nsresult SetLastModifiedTime(PRInt64 aLastModifiedTime) = 0; virtual nsresult GetLastModifiedTimeOfLink(PRInt64 *aLastModifiedTimeOfLink) = 0; virtual nsresult SetLastModifiedTimeOfLink(PRInt64 aLastModifiedTimeOfLink) = 0; virtual nsresult GetFileSize(PRInt64 *aFileSize) = 0; virtual nsresult SetFileSize(PRInt64 aFileSize) = 0; virtual nsresult GetFileSizeOfLink(PRInt64 *aFileSizeOfLink) = 0; virtual nsresult GetTarget(char * *aTarget) = 0; virtual nsresult GetUnicodeTarget(PRUnichar * *aUnicodeTarget) = 0; virtual nsresult GetPath(char * *aPath) = 0; virtual nsresult GetUnicodePath(PRUnichar * *aUnicodePath) = 0; virtual nsresult Exists(PRBool *_retval) = 0; virtual nsresult IsWritable(PRBool *_retval) = 0; virtual nsresult IsReadable(PRBool *_retval) = 0; virtual nsresult IsExecutable(PRBool *_retval) = 0; virtual nsresult IsHidden(PRBool *_retval) = 0; virtual nsresult IsDirectory(PRBool *_retval) = 0; virtual nsresult IsFile(PRBool *_retval) = 0; virtual nsresult IsSymlink(PRBool *_retval) = 0; virtual nsresult IsSpecial(PRBool *_retval) = 0; virtual nsresult CreateUnique(PRUint32 type, PRUint32 permissions) = 0; virtual nsresult Clone(nsIFile **_retval) = 0; virtual nsresult Equals(nsIFile *inFile, PRBool *_retval) = 0; virtual nsresult Contains(nsIFile *inFile, PRBool recur, PRBool *_retval) = 0; virtual nsresult GetParent(nsIFile * *aParent) = 0; virtual nsresult GetDirectoryEntries(nsISimpleEnumerator * *aDirectoryEntries) = 0; }; class nsIProperties : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x61c1b3c0, 0xb1bf, 0x11d3, { 0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}; return iid;} virtual nsresult Define(const char *prop, nsISupports *initialValue) = 0; virtual nsresult Undefine(const char *prop) = 0; virtual nsresult Get(const char *prop, const nsIID & uuid, void * *result) = 0; virtual nsresult Set(const char *prop, nsISupports *value) = 0; virtual nsresult Has(const char *prop, PRBool *_retval) = 0; }; inline nsresult NS_NewIProperties(nsISupports* outer, nsIProperties* *result) { static const nsCID kPropertiesCID = { 0x4de2bc90, 0xb1bf, 0x11d3, {0x93, 0xb6, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} }; return nsComponentManager::CreateInstance(kPropertiesCID, outer, nsCOMTypeInfo::GetIID(), (void**)result); } inline nsresult NS_GetSpecialDirectory(const char* specialDirName, nsIFile* *result) { nsresult rv; static const nsCID kDirectoryServiceCID = {0xf00152d0,0xb40b,0x11d3,{0x8c, 0x9c, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74}}; nsCOMPtr serv(do_GetService(kDirectoryServiceCID, &rv)); if (((rv) & 0x80000000)) return rv; nsCOMPtr dir; rv = serv->Get(specialDirName, nsCOMTypeInfo::GetIID(), getter_AddRefs(dir)); if (((rv) & 0x80000000)) return rv; *result = static_cast< nsIFile* >(static_cast< nsISupports* >(dir)); if (*result) (*result)->AddRef(); return 0; } class nsIDirectoryServiceProvider : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xbbf8cab0, 0xd43a, 0x11d3, { 0x8c, 0xc2, 0x00, 0x60, 0x97, 0x92, 0x27, 0x8c }}; return iid;} virtual nsresult GetFile(const char *prop, PRBool *persistent, nsIFile **_retval) = 0; }; class nsIDirectoryServiceProvider2 : public nsIDirectoryServiceProvider { public: static const nsIID& GetIID() {static const nsIID iid = {0x2f977d4b, 0x5485, 0x11d4, { 0x87, 0xe2, 0x00, 0x10, 0xa4, 0xe7, 0x5e, 0xf2 }}; return iid;} virtual nsresult GetFiles(const char *prop, nsISimpleEnumerator **_retval) = 0; }; class nsIDirectoryService : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x57a66a60, 0xd43a, 0x11d3, { 0x8c, 0xc2, 0x00, 0x60, 0x97, 0x92, 0x27, 0x8c }}; return iid;} virtual nsresult Init(void) = 0; virtual nsresult RegisterProvider(nsIDirectoryServiceProvider *prov) = 0; virtual nsresult UnregisterProvider(nsIDirectoryServiceProvider *prov) = 0; }; extern "C" { typedef unsigned char JSUint8; typedef signed char JSInt8; typedef unsigned short JSUint16; typedef short JSInt16; typedef unsigned int JSUint32; typedef int JSInt32; typedef long long JSInt64; typedef unsigned long long JSUint64; typedef int JSIntn; typedef unsigned int JSUintn; typedef double JSFloat64; typedef size_t JSSize; typedef ptrdiff_t JSPtrdiff; typedef unsigned long JSUptrdiff; typedef JSIntn JSBool; typedef JSUint8 JSPackedBool; typedef long JSWord; typedef unsigned long JSUword; } extern "C" { extern JSInt64 JSLL_MaxInt(void); extern JSInt64 JSLL_MinInt(void); extern JSInt64 JSLL_Zero(void); } typedef JSIntn intN; typedef JSUintn uintN; typedef JSUword jsuword; typedef JSWord jsword; typedef float float32; extern "C" { typedef uint16 jschar; typedef int32 jsint; typedef uint32 jsuint; typedef float64 jsdouble; typedef jsword jsval; typedef jsword jsid; typedef int32 jsrefcount; typedef enum JSVersion { JSVERSION_1_0 = 100, JSVERSION_1_1 = 110, JSVERSION_1_2 = 120, JSVERSION_1_3 = 130, JSVERSION_1_4 = 140, JSVERSION_1_5 = 150, JSVERSION_DEFAULT = 0, JSVERSION_UNKNOWN = -1 } JSVersion; typedef enum JSType { JSTYPE_VOID, JSTYPE_OBJECT, JSTYPE_FUNCTION, JSTYPE_STRING, JSTYPE_NUMBER, JSTYPE_BOOLEAN, JSTYPE_LIMIT } JSType; typedef enum JSAccessMode { JSACC_PROTO, JSACC_PARENT, JSACC_IMPORT, JSACC_WATCH, JSACC_READ, JSACC_WRITE, JSACC_LIMIT } JSAccessMode; typedef enum JSIterateOp { JSENUMERATE_INIT, JSENUMERATE_NEXT, JSENUMERATE_DESTROY } JSIterateOp; typedef struct JSClass JSClass; typedef struct JSConstDoubleSpec JSConstDoubleSpec; typedef struct JSContext JSContext; typedef struct JSErrorReport JSErrorReport; typedef struct JSFunction JSFunction; typedef struct JSFunctionSpec JSFunctionSpec; typedef struct JSIdArray JSIdArray; typedef struct JSProperty JSProperty; typedef struct JSPropertySpec JSPropertySpec; typedef struct JSObject JSObject; typedef struct JSObjectMap JSObjectMap; typedef struct JSObjectOps JSObjectOps; typedef struct JSRuntime JSRuntime; typedef struct JSRuntime JSTaskState; typedef struct JSScript JSScript; typedef struct JSString JSString; typedef struct JSXDRState JSXDRState; typedef struct JSExceptionState JSExceptionState; typedef struct JSLocaleCallbacks JSLocaleCallbacks; typedef JSBool (* JSPropertyOp)(JSContext *cx, JSObject *obj, jsval id, jsval *vp); typedef JSBool (* JSNewEnumerateOp)(JSContext *cx, JSObject *obj, JSIterateOp enum_op, jsval *statep, jsid *idp); typedef JSBool (* JSEnumerateOp)(JSContext *cx, JSObject *obj); typedef JSBool (* JSResolveOp)(JSContext *cx, JSObject *obj, jsval id); typedef JSBool (* JSNewResolveOp)(JSContext *cx, JSObject *obj, jsval id, uintN flags, JSObject **objp); typedef JSBool (* JSConvertOp)(JSContext *cx, JSObject *obj, JSType type, jsval *vp); typedef void (* JSFinalizeOp)(JSContext *cx, JSObject *obj); typedef void (* JSStringFinalizeOp)(JSContext *cx, JSString *str); typedef JSObjectOps * (* JSGetObjectOps)(JSContext *cx, JSClass *clasp); typedef JSBool (* JSCheckAccessOp)(JSContext *cx, JSObject *obj, jsval id, JSAccessMode mode, jsval *vp); typedef JSBool (* JSXDRObjectOp)(JSXDRState *xdr, JSObject **objp); typedef JSBool (* JSHasInstanceOp)(JSContext *cx, JSObject *obj, jsval v, JSBool *bp); typedef uint32 (* JSMarkOp)(JSContext *cx, JSObject *obj, void *arg); typedef JSObjectMap * (* JSNewObjectMapOp)(JSContext *cx, jsrefcount nrefs, JSObjectOps *ops, JSClass *clasp, JSObject *obj); typedef void (* JSObjectMapOp)(JSContext *cx, JSObjectMap *map); typedef JSBool (* JSLookupPropOp)(JSContext *cx, JSObject *obj, jsid id, JSObject **objp, JSProperty **propp , const char *file, uintN line ); typedef JSBool (* JSDefinePropOp)(JSContext *cx, JSObject *obj, jsid id, jsval value, JSPropertyOp getter, JSPropertyOp setter, uintN attrs, JSProperty **propp); typedef JSBool (* JSPropertyIdOp)(JSContext *cx, JSObject *obj, jsid id, jsval *vp); typedef JSBool (* JSAttributesOp)(JSContext *cx, JSObject *obj, jsid id, JSProperty *prop, uintN *attrsp); typedef JSBool (* JSCheckAccessIdOp)(JSContext *cx, JSObject *obj, jsid id, JSAccessMode mode, jsval *vp, uintN *attrsp); typedef JSObject * (* JSObjectOp)(JSContext *cx, JSObject *obj); typedef void (* JSPropertyRefOp)(JSContext *cx, JSObject *obj, JSProperty *prop); typedef JSBool (* JSSetObjectSlotOp)(JSContext *cx, JSObject *obj, uint32 slot, JSObject *pobj); typedef jsval (* JSGetRequiredSlotOp)(JSContext *cx, JSObject *obj, uint32 slot); typedef void (* JSSetRequiredSlotOp)(JSContext *cx, JSObject *obj, uint32 slot, jsval v); typedef JSBool (* JSNative)(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval); typedef enum JSGCStatus { JSGC_BEGIN, JSGC_END, JSGC_MARK_END, JSGC_FINALIZE_END } JSGCStatus; typedef JSBool (* JSGCCallback)(JSContext *cx, JSGCStatus status); typedef JSBool (* JSBranchCallback)(JSContext *cx, JSScript *script); typedef void (* JSErrorReporter)(JSContext *cx, const char *message, JSErrorReport *report); typedef struct JSErrorFormatString { const char *format; uintN argCount; } JSErrorFormatString; typedef const JSErrorFormatString * (* JSErrorCallback)(void *userRef, const char *locale, const uintN errorNumber); typedef JSBool (* JSArgumentFormatter)(JSContext *cx, const char *format, JSBool fromJS, jsval **vpp, va_list *app); typedef JSBool (* JSLocaleToUpperCase)(JSContext *cx, JSString *src, jsval *rval); typedef JSBool (* JSLocaleToLowerCase)(JSContext *cx, JSString *src, jsval *rval); typedef JSBool (* JSLocaleCompare)(JSContext *cx, JSString *src1, JSString *src2, jsval *rval); typedef struct JSPrincipals JSPrincipals; typedef JSBool (* JSPrincipalsTranscoder)(JSXDRState *xdr, JSPrincipals **principalsp); } extern "C" { extern jsval JS_GetNaNValue(JSContext *cx); extern jsval JS_GetNegativeInfinityValue(JSContext *cx); extern jsval JS_GetPositiveInfinityValue(JSContext *cx); extern jsval JS_GetEmptyStringValue(JSContext *cx); extern JSBool JS_ConvertArguments(JSContext *cx, uintN argc, jsval *argv, const char *format, ...); extern JSBool JS_ConvertArgumentsVA(JSContext *cx, uintN argc, jsval *argv, const char *format, va_list ap); extern jsval * JS_PushArguments(JSContext *cx, void **markp, const char *format, ...); extern jsval * JS_PushArgumentsVA(JSContext *cx, void **markp, const char *format, va_list ap); extern void JS_PopArguments(JSContext *cx, void *mark); extern JSBool JS_AddArgumentFormatter(JSContext *cx, const char *format, JSArgumentFormatter formatter); extern void JS_RemoveArgumentFormatter(JSContext *cx, const char *format); extern JSBool JS_ConvertValue(JSContext *cx, jsval v, JSType type, jsval *vp); extern JSBool JS_ValueToObject(JSContext *cx, jsval v, JSObject **objp); extern JSFunction * JS_ValueToFunction(JSContext *cx, jsval v); extern JSFunction * JS_ValueToConstructor(JSContext *cx, jsval v); extern JSString * JS_ValueToString(JSContext *cx, jsval v); extern JSBool JS_ValueToNumber(JSContext *cx, jsval v, jsdouble *dp); extern JSBool JS_ValueToECMAInt32(JSContext *cx, jsval v, int32 *ip); extern JSBool JS_ValueToECMAUint32(JSContext *cx, jsval v, uint32 *ip); extern JSBool JS_ValueToInt32(JSContext *cx, jsval v, int32 *ip); extern JSBool JS_ValueToUint16(JSContext *cx, jsval v, uint16 *ip); extern JSBool JS_ValueToBoolean(JSContext *cx, jsval v, JSBool *bp); extern JSType JS_TypeOfValue(JSContext *cx, jsval v); extern const char * JS_GetTypeName(JSContext *cx, JSType type); extern JSRuntime * JS_Init(uint32 maxbytes); extern void JS_Finish(JSRuntime *rt); extern void JS_ShutDown(void); void * JS_GetRuntimePrivate(JSRuntime *rt); void JS_SetRuntimePrivate(JSRuntime *rt, void *data); extern void JS_BeginRequest(JSContext *cx); extern void JS_EndRequest(JSContext *cx); extern void JS_YieldRequest(JSContext *cx); extern jsrefcount JS_SuspendRequest(JSContext *cx); extern void JS_ResumeRequest(JSContext *cx, jsrefcount saveDepth); extern void JS_Lock(JSRuntime *rt); extern void JS_Unlock(JSRuntime *rt); extern JSContext * JS_NewContext(JSRuntime *rt, size_t stackChunkSize); extern void JS_DestroyContext(JSContext *cx); extern void JS_DestroyContextNoGC(JSContext *cx); extern void JS_DestroyContextMaybeGC(JSContext *cx); extern void * JS_GetContextPrivate(JSContext *cx); extern void JS_SetContextPrivate(JSContext *cx, void *data); extern JSRuntime * JS_GetRuntime(JSContext *cx); extern JSContext * JS_ContextIterator(JSRuntime *rt, JSContext **iterp); extern JSVersion JS_GetVersion(JSContext *cx); extern JSVersion JS_SetVersion(JSContext *cx, JSVersion version); extern const char * JS_VersionToString(JSVersion version); extern JSVersion JS_StringToVersion(const char *string); extern uint32 JS_GetOptions(JSContext *cx); extern uint32 JS_SetOptions(JSContext *cx, uint32 options); extern uint32 JS_ToggleOptions(JSContext *cx, uint32 options); extern const char * JS_GetImplementationVersion(void); extern JSObject * JS_GetGlobalObject(JSContext *cx); extern void JS_SetGlobalObject(JSContext *cx, JSObject *obj); extern JSBool JS_InitStandardClasses(JSContext *cx, JSObject *obj); extern JSBool JS_ResolveStandardClass(JSContext *cx, JSObject *obj, jsval id, JSBool *resolved); extern JSBool JS_EnumerateStandardClasses(JSContext *cx, JSObject *obj); extern JSObject * JS_GetScopeChain(JSContext *cx); extern void * JS_malloc(JSContext *cx, size_t nbytes); extern void * JS_realloc(JSContext *cx, void *p, size_t nbytes); extern void JS_free(JSContext *cx, void *p); extern char * JS_strdup(JSContext *cx, const char *s); extern jsdouble * JS_NewDouble(JSContext *cx, jsdouble d); extern JSBool JS_NewDoubleValue(JSContext *cx, jsdouble d, jsval *rval); extern JSBool JS_NewNumberValue(JSContext *cx, jsdouble d, jsval *rval); extern JSBool JS_AddRoot(JSContext *cx, void *rp); extern JSBool JS_AddNamedRoot(JSContext *cx, void *rp, const char *name); extern JSBool JS_AddNamedRootRT(JSRuntime *rt, void *rp, const char *name); extern JSBool JS_RemoveRoot(JSContext *cx, void *rp); extern JSBool JS_RemoveRootRT(JSRuntime *rt, void *rp); extern void JS_ClearNewbornRoots(JSContext *cx); extern void JS_DumpNamedRoots(JSRuntime *rt, void (*dump)(const char *name, void *rp, void *data), void *data); typedef intN (* JSGCRootMapFun)(void *rp, const char *name, void *data); extern uint32 JS_MapGCRoots(JSRuntime *rt, JSGCRootMapFun map, void *data); extern JSBool JS_LockGCThing(JSContext *cx, void *thing); extern JSBool JS_UnlockGCThing(JSContext *cx, void *thing); extern void JS_MarkGCThing(JSContext *cx, void *thing, const char *name, void *arg); extern void JS_GC(JSContext *cx); extern void JS_MaybeGC(JSContext *cx); extern JSGCCallback JS_SetGCCallback(JSContext *cx, JSGCCallback cb); extern JSGCCallback JS_SetGCCallbackRT(JSRuntime *rt, JSGCCallback cb); extern JSBool JS_IsAboutToBeFinalized(JSContext *cx, void *thing); extern intN JS_AddExternalStringFinalizer(JSStringFinalizeOp finalizer); extern intN JS_RemoveExternalStringFinalizer(JSStringFinalizeOp finalizer); extern JSString * JS_NewExternalString(JSContext *cx, jschar *chars, size_t length, intN type); extern intN JS_GetExternalStringGCType(JSRuntime *rt, JSString *str); struct JSClass { const char *name; uint32 flags; JSPropertyOp addProperty; JSPropertyOp delProperty; JSPropertyOp getProperty; JSPropertyOp setProperty; JSEnumerateOp enumerate; JSResolveOp resolve; JSConvertOp convert; JSFinalizeOp finalize; JSGetObjectOps getObjectOps; JSCheckAccessOp checkAccess; JSNative call; JSNative construct; JSXDRObjectOp xdrObject; JSHasInstanceOp hasInstance; JSMarkOp mark; jsword spare; }; struct JSObjectOps { JSNewObjectMapOp newObjectMap; JSObjectMapOp destroyObjectMap; JSLookupPropOp lookupProperty; JSDefinePropOp defineProperty; JSPropertyIdOp getProperty; JSPropertyIdOp setProperty; JSAttributesOp getAttributes; JSAttributesOp setAttributes; JSPropertyIdOp deleteProperty; JSConvertOp defaultValue; JSNewEnumerateOp enumerate; JSCheckAccessIdOp checkAccess; JSObjectOp thisObject; JSPropertyRefOp dropProperty; JSNative call; JSNative construct; JSXDRObjectOp xdrObject; JSHasInstanceOp hasInstance; JSSetObjectSlotOp setProto; JSSetObjectSlotOp setParent; JSMarkOp mark; JSFinalizeOp clear; JSGetRequiredSlotOp getRequiredSlot; JSSetRequiredSlotOp setRequiredSlot; }; struct JSProperty { jsid id; }; struct JSIdArray { jsint length; jsid vector[1]; }; extern void JS_DestroyIdArray(JSContext *cx, JSIdArray *ida); extern JSBool JS_ValueToId(JSContext *cx, jsval v, jsid *idp); extern JSBool JS_IdToValue(JSContext *cx, jsid id, jsval *vp); extern JSBool JS_PropertyStub(JSContext *cx, JSObject *obj, jsval id, jsval *vp); extern JSBool JS_EnumerateStub(JSContext *cx, JSObject *obj); extern JSBool JS_ResolveStub(JSContext *cx, JSObject *obj, jsval id); extern JSBool JS_ConvertStub(JSContext *cx, JSObject *obj, JSType type, jsval *vp); extern void JS_FinalizeStub(JSContext *cx, JSObject *obj); struct JSConstDoubleSpec { jsdouble dval; const char *name; uint8 flags; uint8 spare[3]; }; struct JSPropertySpec { const char *name; int8 tinyid; uint8 flags; JSPropertyOp getter; JSPropertyOp setter; }; struct JSFunctionSpec { const char *name; JSNative call; uint8 nargs; uint8 flags; uint16 extra; }; extern JSObject * JS_InitClass(JSContext *cx, JSObject *obj, JSObject *parent_proto, JSClass *clasp, JSNative constructor, uintN nargs, JSPropertySpec *ps, JSFunctionSpec *fs, JSPropertySpec *static_ps, JSFunctionSpec *static_fs); extern JSClass * JS_GetClass(JSContext *cx, JSObject *obj); extern JSBool JS_InstanceOf(JSContext *cx, JSObject *obj, JSClass *clasp, jsval *argv); extern void * JS_GetPrivate(JSContext *cx, JSObject *obj); extern JSBool JS_SetPrivate(JSContext *cx, JSObject *obj, void *data); extern void * JS_GetInstancePrivate(JSContext *cx, JSObject *obj, JSClass *clasp, jsval *argv); extern JSObject * JS_GetPrototype(JSContext *cx, JSObject *obj); extern JSBool JS_SetPrototype(JSContext *cx, JSObject *obj, JSObject *proto); extern JSObject * JS_GetParent(JSContext *cx, JSObject *obj); extern JSBool JS_SetParent(JSContext *cx, JSObject *obj, JSObject *parent); extern JSObject * JS_GetConstructor(JSContext *cx, JSObject *proto); extern JSObject * JS_NewObject(JSContext *cx, JSClass *clasp, JSObject *proto, JSObject *parent); extern JSObject * JS_ConstructObject(JSContext *cx, JSClass *clasp, JSObject *proto, JSObject *parent); extern JSObject * JS_DefineObject(JSContext *cx, JSObject *obj, const char *name, JSClass *clasp, JSObject *proto, uintN attrs); extern JSBool JS_DefineConstDoubles(JSContext *cx, JSObject *obj, JSConstDoubleSpec *cds); extern JSBool JS_DefineProperties(JSContext *cx, JSObject *obj, JSPropertySpec *ps); extern JSBool JS_DefineProperty(JSContext *cx, JSObject *obj, const char *name, jsval value, JSPropertyOp getter, JSPropertyOp setter, uintN attrs); extern JSBool JS_GetPropertyAttributes(JSContext *cx, JSObject *obj, const char *name, uintN *attrsp, JSBool *foundp); extern JSBool JS_SetPropertyAttributes(JSContext *cx, JSObject *obj, const char *name, uintN attrs, JSBool *foundp); extern JSBool JS_DefinePropertyWithTinyId(JSContext *cx, JSObject *obj, const char *name, int8 tinyid, jsval value, JSPropertyOp getter, JSPropertyOp setter, uintN attrs); extern JSBool JS_AliasProperty(JSContext *cx, JSObject *obj, const char *name, const char *alias); extern JSBool JS_LookupProperty(JSContext *cx, JSObject *obj, const char *name, jsval *vp); extern JSBool JS_GetProperty(JSContext *cx, JSObject *obj, const char *name, jsval *vp); extern JSBool JS_SetProperty(JSContext *cx, JSObject *obj, const char *name, jsval *vp); extern JSBool JS_DeleteProperty(JSContext *cx, JSObject *obj, const char *name); extern JSBool JS_DeleteProperty2(JSContext *cx, JSObject *obj, const char *name, jsval *rval); extern JSBool JS_DefineUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval value, JSPropertyOp getter, JSPropertyOp setter, uintN attrs); extern JSBool JS_GetUCPropertyAttributes(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, uintN *attrsp, JSBool *foundp); extern JSBool JS_SetUCPropertyAttributes(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, uintN attrs, JSBool *foundp); extern JSBool JS_DefineUCPropertyWithTinyId(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, int8 tinyid, jsval value, JSPropertyOp getter, JSPropertyOp setter, uintN attrs); extern JSBool JS_LookupUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *vp); extern JSBool JS_GetUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *vp); extern JSBool JS_SetUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *vp); extern JSBool JS_DeleteUCProperty2(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *rval); extern JSObject * JS_NewArrayObject(JSContext *cx, jsint length, jsval *vector); extern JSBool JS_IsArrayObject(JSContext *cx, JSObject *obj); extern JSBool JS_GetArrayLength(JSContext *cx, JSObject *obj, jsuint *lengthp); extern JSBool JS_SetArrayLength(JSContext *cx, JSObject *obj, jsuint length); extern JSBool JS_HasArrayLength(JSContext *cx, JSObject *obj, jsuint *lengthp); extern JSBool JS_DefineElement(JSContext *cx, JSObject *obj, jsint index, jsval value, JSPropertyOp getter, JSPropertyOp setter, uintN attrs); extern JSBool JS_AliasElement(JSContext *cx, JSObject *obj, const char *name, jsint alias); extern JSBool JS_LookupElement(JSContext *cx, JSObject *obj, jsint index, jsval *vp); extern JSBool JS_GetElement(JSContext *cx, JSObject *obj, jsint index, jsval *vp); extern JSBool JS_SetElement(JSContext *cx, JSObject *obj, jsint index, jsval *vp); extern JSBool JS_DeleteElement(JSContext *cx, JSObject *obj, jsint index); extern JSBool JS_DeleteElement2(JSContext *cx, JSObject *obj, jsint index, jsval *rval); extern void JS_ClearScope(JSContext *cx, JSObject *obj); extern JSIdArray * JS_Enumerate(JSContext *cx, JSObject *obj); extern JSBool JS_CheckAccess(JSContext *cx, JSObject *obj, jsid id, JSAccessMode mode, jsval *vp, uintN *attrsp); extern JSCheckAccessOp JS_SetCheckObjectAccessCallback(JSRuntime *rt, JSCheckAccessOp acb); extern JSBool JS_GetReservedSlot(JSContext *cx, JSObject *obj, uint32 index, jsval *vp); extern JSBool JS_SetReservedSlot(JSContext *cx, JSObject *obj, uint32 index, jsval v); struct JSPrincipals { char *codebase; void * (* getPrincipalArray)(JSContext *cx, JSPrincipals *); JSBool (* globalPrivilegesEnabled)(JSContext *cx, JSPrincipals *); uintN refcount; void (* destroy)(JSContext *cx, struct JSPrincipals *); }; extern JSPrincipalsTranscoder JS_SetPrincipalsTranscoder(JSRuntime *rt, JSPrincipalsTranscoder px); extern JSFunction * JS_NewFunction(JSContext *cx, JSNative call, uintN nargs, uintN flags, JSObject *parent, const char *name); extern JSObject * JS_GetFunctionObject(JSFunction *fun); extern const char * JS_GetFunctionName(JSFunction *fun); extern JSBool JS_DefineFunctions(JSContext *cx, JSObject *obj, JSFunctionSpec *fs); extern JSFunction * JS_DefineFunction(JSContext *cx, JSObject *obj, const char *name, JSNative call, uintN nargs, uintN attrs); extern JSObject * JS_CloneFunctionObject(JSContext *cx, JSObject *funobj, JSObject *parent); extern JSBool JS_BufferIsCompilableUnit(JSContext *cx, JSObject *obj, const char *bytes, size_t length); extern JSScript * JS_CompileScript(JSContext *cx, JSObject *obj, const char *bytes, size_t length, const char *filename, uintN lineno); extern JSScript * JS_CompileScriptForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals, const char *bytes, size_t length, const char *filename, uintN lineno); extern JSScript * JS_CompileUCScript(JSContext *cx, JSObject *obj, const jschar *chars, size_t length, const char *filename, uintN lineno); extern JSScript * JS_CompileUCScriptForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals, const jschar *chars, size_t length, const char *filename, uintN lineno); extern JSScript * JS_CompileFile(JSContext *cx, JSObject *obj, const char *filename); extern JSScript * JS_CompileFileHandle(JSContext *cx, JSObject *obj, const char *filename, FILE *fh); extern JSScript * JS_CompileFileHandleForPrincipals(JSContext *cx, JSObject *obj, const char *filename, FILE *fh, JSPrincipals *principals); extern JSObject * JS_NewScriptObject(JSContext *cx, JSScript *script); extern void JS_DestroyScript(JSContext *cx, JSScript *script); extern JSFunction * JS_CompileFunction(JSContext *cx, JSObject *obj, const char *name, uintN nargs, const char **argnames, const char *bytes, size_t length, const char *filename, uintN lineno); extern JSFunction * JS_CompileFunctionForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals, const char *name, uintN nargs, const char **argnames, const char *bytes, size_t length, const char *filename, uintN lineno); extern JSFunction * JS_CompileUCFunction(JSContext *cx, JSObject *obj, const char *name, uintN nargs, const char **argnames, const jschar *chars, size_t length, const char *filename, uintN lineno); extern JSFunction * JS_CompileUCFunctionForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals, const char *name, uintN nargs, const char **argnames, const jschar *chars, size_t length, const char *filename, uintN lineno); extern JSString * JS_DecompileScript(JSContext *cx, JSScript *script, const char *name, uintN indent); extern JSString * JS_DecompileFunction(JSContext *cx, JSFunction *fun, uintN indent); extern JSString * JS_DecompileFunctionBody(JSContext *cx, JSFunction *fun, uintN indent); extern JSBool JS_ExecuteScript(JSContext *cx, JSObject *obj, JSScript *script, jsval *rval); typedef enum JSExecPart { JSEXEC_PROLOG, JSEXEC_MAIN } JSExecPart; extern JSBool JS_ExecuteScriptPart(JSContext *cx, JSObject *obj, JSScript *script, JSExecPart part, jsval *rval); extern JSBool JS_EvaluateScript(JSContext *cx, JSObject *obj, const char *bytes, uintN length, const char *filename, uintN lineno, jsval *rval); extern JSBool JS_EvaluateScriptForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals, const char *bytes, uintN length, const char *filename, uintN lineno, jsval *rval); extern JSBool JS_EvaluateUCScript(JSContext *cx, JSObject *obj, const jschar *chars, uintN length, const char *filename, uintN lineno, jsval *rval); extern JSBool JS_EvaluateUCScriptForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals, const jschar *chars, uintN length, const char *filename, uintN lineno, jsval *rval); extern JSBool JS_CallFunction(JSContext *cx, JSObject *obj, JSFunction *fun, uintN argc, jsval *argv, jsval *rval); extern JSBool JS_CallFunctionName(JSContext *cx, JSObject *obj, const char *name, uintN argc, jsval *argv, jsval *rval); extern JSBool JS_CallFunctionValue(JSContext *cx, JSObject *obj, jsval fval, uintN argc, jsval *argv, jsval *rval); extern JSBranchCallback JS_SetBranchCallback(JSContext *cx, JSBranchCallback cb); extern JSBool JS_IsRunning(JSContext *cx); extern JSBool JS_IsConstructing(JSContext *cx); extern JSBool JS_IsAssigning(JSContext *cx); extern void JS_SetCallReturnValue2(JSContext *cx, jsval v); extern JSString * JS_NewString(JSContext *cx, char *bytes, size_t length); extern JSString * JS_NewStringCopyN(JSContext *cx, const char *s, size_t n); extern JSString * JS_NewStringCopyZ(JSContext *cx, const char *s); extern JSString * JS_InternString(JSContext *cx, const char *s); extern JSString * JS_NewUCString(JSContext *cx, jschar *chars, size_t length); extern JSString * JS_NewUCStringCopyN(JSContext *cx, const jschar *s, size_t n); extern JSString * JS_NewUCStringCopyZ(JSContext *cx, const jschar *s); extern JSString * JS_InternUCStringN(JSContext *cx, const jschar *s, size_t length); extern JSString * JS_InternUCString(JSContext *cx, const jschar *s); extern char * JS_GetStringBytes(JSString *str); extern jschar * JS_GetStringChars(JSString *str); extern size_t JS_GetStringLength(JSString *str); extern intN JS_CompareStrings(JSString *str1, JSString *str2); extern JSString * JS_NewGrowableString(JSContext *cx, jschar *chars, size_t length); extern JSString * JS_NewDependentString(JSContext *cx, JSString *str, size_t start, size_t length); extern JSString * JS_ConcatStrings(JSContext *cx, JSString *left, JSString *right); extern const jschar * JS_UndependString(JSContext *cx, JSString *str); extern JSBool JS_MakeStringImmutable(JSContext *cx, JSString *str); struct JSLocaleCallbacks { JSLocaleToUpperCase localeToUpperCase; JSLocaleToLowerCase localeToLowerCase; JSLocaleCompare localeCompare; }; extern void JS_SetLocaleCallbacks(JSContext *cx, JSLocaleCallbacks *callbacks); extern JSLocaleCallbacks * JS_GetLocaleCallbacks(JSContext *cx); extern void JS_ReportError(JSContext *cx, const char *format, ...); extern void JS_ReportErrorNumber(JSContext *cx, JSErrorCallback errorCallback, void *userRef, const uintN errorNumber, ...); extern void JS_ReportErrorNumberUC(JSContext *cx, JSErrorCallback errorCallback, void *userRef, const uintN errorNumber, ...); extern JSBool JS_ReportWarning(JSContext *cx, const char *format, ...); extern JSBool JS_ReportErrorFlagsAndNumber(JSContext *cx, uintN flags, JSErrorCallback errorCallback, void *userRef, const uintN errorNumber, ...); extern JSBool JS_ReportErrorFlagsAndNumberUC(JSContext *cx, uintN flags, JSErrorCallback errorCallback, void *userRef, const uintN errorNumber, ...); extern void JS_ReportOutOfMemory(JSContext *cx); struct JSErrorReport { const char *filename; uintN lineno; const char *linebuf; const char *tokenptr; const jschar *uclinebuf; const jschar *uctokenptr; uintN flags; uintN errorNumber; const jschar *ucmessage; const jschar **messageArgs; }; extern JSErrorReporter JS_SetErrorReporter(JSContext *cx, JSErrorReporter er); extern JSObject * JS_NewRegExpObject(JSContext *cx, char *bytes, size_t length, uintN flags); extern JSObject * JS_NewUCRegExpObject(JSContext *cx, jschar *chars, size_t length, uintN flags); extern void JS_SetRegExpInput(JSContext *cx, JSString *input, JSBool multiline); extern void JS_ClearRegExpStatics(JSContext *cx); extern void JS_ClearRegExpRoots(JSContext *cx); extern JSBool JS_IsExceptionPending(JSContext *cx); extern JSBool JS_GetPendingException(JSContext *cx, jsval *vp); extern void JS_SetPendingException(JSContext *cx, jsval v); extern void JS_ClearPendingException(JSContext *cx); extern JSExceptionState * JS_SaveExceptionState(JSContext *cx); extern void JS_RestoreExceptionState(JSContext *cx, JSExceptionState *state); extern void JS_DropExceptionState(JSContext *cx, JSExceptionState *state); extern JSErrorReport * JS_ErrorFromException(JSContext *cx, jsval v); extern intN JS_GetContextThread(JSContext *cx); extern intN JS_SetContextThread(JSContext *cx); extern intN JS_ClearContextThread(JSContext *cx); } extern "C" { typedef struct PLEvent PLEvent; typedef struct PLEventQueue PLEventQueue; extern PLEventQueue* PL_CreateEventQueue(char* name, PRThread* handlerThread); extern PLEventQueue * PL_CreateNativeEventQueue( char *name, PRThread *handlerThread ); extern PLEventQueue * PL_CreateMonitoredEventQueue( char *name, PRThread *handlerThread ); extern void PL_DestroyEventQueue(PLEventQueue* self); extern PRMonitor* PL_GetEventQueueMonitor(PLEventQueue* self); extern PRStatus PL_PostEvent(PLEventQueue* self, PLEvent* event); extern void* PL_PostSynchronousEvent(PLEventQueue* self, PLEvent* event); extern PLEvent* PL_GetEvent(PLEventQueue* self); extern PRBool PL_EventAvailable(PLEventQueue* self); typedef void ( *PLEventFunProc)(PLEvent* event, void* data, PLEventQueue* queue); extern void PL_MapEvents(PLEventQueue* self, PLEventFunProc fun, void* data); extern void PL_RevokeEvents(PLEventQueue* self, void* owner); extern void PL_ProcessPendingEvents(PLEventQueue* self); extern PLEvent* PL_WaitForEvent(PLEventQueue* self); extern void PL_EventLoop(PLEventQueue* self); extern PRInt32 PL_GetEventQueueSelectFD(PLEventQueue* self); extern PRBool PL_IsQueueOnCurrentThread( PLEventQueue *queue ); extern PRBool PL_IsQueueNative(PLEventQueue *queue); typedef void* ( *PLHandleEventProc)(PLEvent* self); typedef void ( *PLDestroyEventProc)(PLEvent* self); extern void PL_InitEvent(PLEvent* self, void* owner, PLHandleEventProc handler, PLDestroyEventProc destructor); extern void* PL_GetEventOwner(PLEvent* self); extern void PL_HandleEvent(PLEvent* self); extern void PL_DestroyEvent(PLEvent* self); extern void PL_DequeueEvent(PLEvent* self, PLEventQueue* queue); struct PLEvent { PRCList link; PLHandleEventProc handler; PLDestroyEventProc destructor; void* owner; void* synchronousResult; PRLock* lock; PRCondVar* condVar; PRBool handled; unsigned long id; }; extern PRInt32 PL_ProcessEventsBeforeID(PLEventQueue *aSelf, unsigned long aID); typedef unsigned long ( *PLGetEventIDFunc)(void *aClosure); extern void PL_RegisterEventIDFunc(PLEventQueue *aSelf, PLGetEventIDFunc aFunc, void *aClosure); extern void PL_UnregisterEventIDFunc(PLEventQueue *aSelf); } class nsISizeOfHandler; typedef const nsAString nsAReadableString; typedef const nsACString nsAReadableCString; class nsDependentString : public nsAFlatString { public: typedef nsDependentString self_type; void Rebind( const char_type* aPtr ) { if (!(aPtr)) nsDebug::Assertion("nsDependentString must wrap a non-NULL buffer", "aPtr", "../../dist/include/string/nsDependentString.h", 54); mHandle.DataStart(aPtr); mHandle.DataEnd(aPtr ? (aPtr+nsCharTraits::length(aPtr)) : 0); } void Rebind( const char_type* aStartPtr, const char_type* aEndPtr ) { if (!(aStartPtr && aEndPtr)) nsDebug::Assertion("nsDependentString must wrap a non-NULL buffer", "aStartPtr && aEndPtr", "../../dist/include/string/nsDependentString.h", 65); if (!(!*aEndPtr)) nsDebug::Assertion("nsDependentString must wrap only null-terminated strings", "!*aEndPtr", "../../dist/include/string/nsDependentString.h", 86); mHandle.DataStart(aStartPtr); mHandle.DataEnd(aEndPtr); } void Rebind( const char_type* aPtr, PRUint32 aLength ) { if (!(aLength != PRUint32(-1))) nsDebug::Assertion("caller passing bogus length", "aLength != PRUint32(-1)", "../../dist/include/string/nsDependentString.h", 94); Rebind(aPtr, aPtr+aLength); } nsDependentString( const char_type* aStartPtr, const char_type* aEndPtr ) { Rebind(aStartPtr, aEndPtr); } nsDependentString( const char_type* aPtr, PRUint32 aLength ) { Rebind(aPtr, aLength); } explicit nsDependentString( const char_type* aPtr ) { Rebind(aPtr); } private: void operator=( const self_type& ); public: virtual const buffer_handle_type* GetFlatBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } virtual const buffer_handle_type* GetBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } private: const_buffer_handle_type mHandle; }; class nsDependentCString : public nsAFlatCString { public: typedef nsDependentCString self_type; void Rebind( const char_type* aPtr ) { if (!(aPtr)) nsDebug::Assertion("nsDependentCString must wrap a non-NULL buffer", "aPtr", "../../dist/include/string/nsDependentString.h", 128); mHandle.DataStart(aPtr); mHandle.DataEnd(aPtr ? (aPtr+nsCharTraits::length(aPtr)) : 0); } void Rebind( const char_type* aStartPtr, const char_type* aEndPtr ) { if (!(aStartPtr && aEndPtr)) nsDebug::Assertion("nsDependentCString must wrap a non-NULL buffer", "aStartPtr && aEndPtr", "../../dist/include/string/nsDependentString.h", 139); if (!(!*aEndPtr)) nsDebug::Assertion("nsDependentCString must wrap only null-terminated strings", "!*aEndPtr", "../../dist/include/string/nsDependentString.h", 160); mHandle.DataStart(aStartPtr); mHandle.DataEnd(aEndPtr); } void Rebind( const char_type* aPtr, PRUint32 aLength ) { if (!(aLength != PRUint32(-1))) nsDebug::Assertion("caller passing bogus length", "aLength != PRUint32(-1)", "../../dist/include/string/nsDependentString.h", 168); Rebind(aPtr, aPtr+aLength); } nsDependentCString( const char_type* aStartPtr, const char_type* aEndPtr ) { Rebind(aStartPtr, aEndPtr); } nsDependentCString( const char_type* aPtr, PRUint32 aLength ) { Rebind(aPtr, aLength); } explicit nsDependentCString( const char_type* aPtr ) { Rebind(aPtr); } private: void operator=( const self_type& ); public: virtual const buffer_handle_type* GetFlatBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } virtual const buffer_handle_type* GetBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } private: const_buffer_handle_type mHandle; }; class nsDependentSubstring : public nsAPromiseString { public: typedef nsDependentSubstring self_type; protected: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ) { return 0; } public: nsDependentSubstring( const abstract_string_type& aString, PRUint32 aStartPos, PRUint32 aLength ) : mString(aString), mStartPos( NS_MIN(aStartPos, aString.Length()) ), mLength( NS_MIN(aLength, aString.Length()-mStartPos) ) { } nsDependentSubstring( const const_iterator& aStart, const const_iterator& aEnd ) : mString(aStart.string()) { const_iterator zeroPoint; mString.BeginReading(zeroPoint); mStartPos = Distance(zeroPoint, aStart); mLength = Distance(aStart, aEnd); } private: void operator=( const self_type& ); public: virtual PRUint32 Length() const; virtual PRBool IsDependentOn( const abstract_string_type& aString ) const { return mString.IsDependentOn(aString); } private: const abstract_string_type& mString; PRUint32 mStartPos; PRUint32 mLength; }; class nsDependentCSubstring : public nsAPromiseCString { public: typedef nsDependentCSubstring self_type; protected: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; virtual char_type* GetWritableFragment( fragment_type&, nsFragmentRequest, PRUint32 ) { return 0; } public: nsDependentCSubstring( const abstract_string_type& aString, PRUint32 aStartPos, PRUint32 aLength ) : mString(aString), mStartPos( NS_MIN(aStartPos, aString.Length()) ), mLength( NS_MIN(aLength, aString.Length()-mStartPos) ) { } nsDependentCSubstring( const const_iterator& aStart, const const_iterator& aEnd ) : mString(aStart.string()) { const_iterator zeroPoint; mString.BeginReading(zeroPoint); mStartPos = Distance(zeroPoint, aStart); mLength = Distance(aStart, aEnd); } private: void operator=( const self_type& ); public: virtual PRUint32 Length() const; virtual PRBool IsDependentOn( const abstract_string_type& aString ) const { return mString.IsDependentOn(aString); } private: const abstract_string_type& mString; PRUint32 mStartPos; PRUint32 mLength; }; class nsDependentSingleFragmentSubstring : public nsASingleFragmentString { public: typedef nsDependentSingleFragmentSubstring self_type; typedef nsASingleFragmentString abstract_single_fragment_type; void Rebind( const char_type* aStartPtr, const char_type* aEndPtr ) { if (!(aStartPtr && aEndPtr)) nsDebug::Assertion("nsDependentSingleFragmentString must wrap a non-NULL buffer", "aStartPtr && aEndPtr", "../../dist/include/string/nsDependentSubstring.h", 162); mHandle.DataStart(aStartPtr); mHandle.DataEnd(aEndPtr); } void Rebind( const abstract_single_fragment_type& aString, const PRUint32 aStartPos, const PRUint32 aLength ) { const_char_iterator iter; mHandle.DataStart(aString.BeginReading(iter) + NS_MIN(aStartPos, aString.Length())); mHandle.DataEnd( NS_MIN(mHandle.DataStart() + aLength, aString.EndReading(iter)) ); } nsDependentSingleFragmentSubstring( const char_type* aStartPtr, const char_type* aEndPtr ) { Rebind(aStartPtr, aEndPtr); } nsDependentSingleFragmentSubstring( const abstract_single_fragment_type& aString, const PRUint32 aStartPos, const PRUint32 aLength ) { Rebind(aString, aStartPos, aLength); } private: void operator=( const self_type& ); public: virtual const buffer_handle_type* GetFlatBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } virtual const buffer_handle_type* GetBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } private: const_buffer_handle_type mHandle; }; class nsDependentSingleFragmentCSubstring : public nsASingleFragmentCString { public: typedef nsDependentSingleFragmentCSubstring self_type; typedef nsASingleFragmentCString abstract_single_fragment_type; void Rebind( const char_type* aStartPtr, const char_type* aEndPtr ) { if (!(aStartPtr && aEndPtr)) nsDebug::Assertion("nsDependentSingleFragmentCString must wrap a non-NULL buffer", "aStartPtr && aEndPtr", "../../dist/include/string/nsDependentSubstring.h", 204); mHandle.DataStart(aStartPtr); mHandle.DataEnd(aEndPtr); } void Rebind( const abstract_single_fragment_type& aString, const PRUint32 aStartPos, const PRUint32 aLength ) { const_char_iterator iter; mHandle.DataStart(aString.BeginReading(iter) + NS_MIN(aStartPos, aString.Length())); mHandle.DataEnd( NS_MIN(mHandle.DataStart() + aLength, aString.EndReading(iter)) ); } nsDependentSingleFragmentCSubstring( const char_type* aStartPtr, const char_type* aEndPtr ) { Rebind(aStartPtr, aEndPtr); } nsDependentSingleFragmentCSubstring( const abstract_single_fragment_type& aString, const PRUint32 aStartPos, const PRUint32 aLength ) { Rebind(aString, aStartPos, aLength); } private: void operator=( const self_type& ); public: virtual const buffer_handle_type* GetFlatBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } virtual const buffer_handle_type* GetBufferHandle() const { return reinterpret_cast< const buffer_handle_type* >(&mHandle); } private: const_buffer_handle_type mHandle; }; inline const nsDependentCSubstring Substring( const nsACString& aString, PRUint32 aStartPos, PRUint32 aSubstringLength ) { return nsDependentCSubstring(aString, aStartPos, aSubstringLength); } inline const nsDependentSubstring Substring( const nsAString& aString, PRUint32 aStartPos, PRUint32 aSubstringLength ) { return nsDependentSubstring(aString, aStartPos, aSubstringLength); } inline const nsDependentCSubstring Substring( const nsACString::const_iterator& aStart, const nsACString::const_iterator& aEnd ) { return nsDependentCSubstring(aStart, aEnd); } inline const nsDependentSubstring Substring( const nsAString::const_iterator& aStart, const nsAString::const_iterator& aEnd ) { return nsDependentSubstring(aStart, aEnd); } inline const nsDependentSingleFragmentCSubstring Substring( const nsASingleFragmentCString& aString, PRUint32 aStartPos, PRUint32 aSubstringLength ) { return nsDependentSingleFragmentCSubstring(aString, aStartPos, aSubstringLength); } inline const nsDependentSingleFragmentSubstring Substring( const nsASingleFragmentString& aString, PRUint32 aStartPos, PRUint32 aSubstringLength ) { return nsDependentSingleFragmentSubstring(aString, aStartPos, aSubstringLength); } inline const nsDependentSingleFragmentCSubstring Substring( const nsASingleFragmentCString::const_char_iterator& aStart, const nsASingleFragmentCString::const_char_iterator& aEnd ) { return nsDependentSingleFragmentCSubstring(aStart, aEnd); } inline const nsDependentSingleFragmentSubstring Substring( const nsASingleFragmentString::const_char_iterator& aStart, const nsASingleFragmentString::const_char_iterator& aEnd ) { return nsDependentSingleFragmentSubstring(aStart, aEnd); } class nsPromiseFlatString : public nsAFlatString { friend const nsPromiseFlatString PromiseFlatString( const abstract_string_type& ); public: typedef nsPromiseFlatString self_type; public: nsPromiseFlatString( const self_type& ); protected: nsPromiseFlatString() : mPromisedString(&mFlattenedString) { } explicit nsPromiseFlatString( const abstract_string_type& aString ); virtual const buffer_handle_type* GetFlatBufferHandle() const; virtual const buffer_handle_type* GetBufferHandle() const; virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; virtual PRBool IsDependentOn( const abstract_string_type& ) const; public: virtual const char_type* get() const; virtual PRUint32 Length() const; protected: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; private: void operator=( const nsPromiseFlatString& ); private: nsSharableString mFlattenedString; const nsAFlatString* mPromisedString; }; class nsPromiseFlatCString : public nsAFlatCString { friend const nsPromiseFlatCString PromiseFlatCString( const abstract_string_type& ); public: typedef nsPromiseFlatCString self_type; public: nsPromiseFlatCString( const self_type& ); protected: nsPromiseFlatCString() : mPromisedString(&mFlattenedString) { } explicit nsPromiseFlatCString( const abstract_string_type& aString ); virtual const buffer_handle_type* GetFlatBufferHandle() const; virtual const buffer_handle_type* GetBufferHandle() const; virtual const shared_buffer_handle_type* GetSharedBufferHandle() const; virtual PRBool IsDependentOn( const abstract_string_type& ) const; public: virtual const char_type* get() const; virtual PRUint32 Length() const; protected: virtual const char_type* GetReadableFragment( const_fragment_type&, nsFragmentRequest, PRUint32 ) const; private: void operator=( const self_type& ); private: nsSharableCString mFlattenedString; const nsAFlatCString* mPromisedString; }; inline const nsPromiseFlatString PromiseFlatString( const nsAString& aString ) { return nsPromiseFlatString(aString); } inline const nsPromiseFlatCString PromiseFlatCString( const nsACString& aString ) { return nsPromiseFlatCString(aString); } typedef nsAString nsAWritableString; typedef nsACString nsAWritableCString; class nsIAtom : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x3d1b15b0, 0x93b4, 0x11d1, { 0x89, 0x5b, 0x00, 0x60, 0x08, 0x91, 0x1b, 0x81 }}; return iid;} virtual nsresult ToString(nsAWritableString & aString) = 0; virtual nsresult GetUnicode(const PRUnichar **aResult) = 0; virtual nsresult SizeOf(nsISizeOfHandler *aHandler, PRUint32 *_retval) = 0; }; extern nsIAtom* NS_NewAtom(const char* isolatin1); extern nsIAtom* NS_NewPermanentAtom(const char* isolatin1); inline already_AddRefed do_GetAtom(const char* isolatin1) { return NS_NewAtom(isolatin1); } inline already_AddRefed do_GetPermanentAtom(const char* isolatin1) { return NS_NewPermanentAtom(isolatin1); } extern nsIAtom* NS_NewAtom(const PRUnichar* unicode); extern nsIAtom* NS_NewPermanentAtom(const PRUnichar* unicode); inline already_AddRefed do_GetAtom(const PRUnichar* unicode) { return NS_NewAtom(unicode); } inline already_AddRefed do_GetPermanentAtom(const PRUnichar* unicode) { return NS_NewPermanentAtom(unicode); } extern nsIAtom* NS_NewAtom(const nsAReadableString& aString); extern nsIAtom* NS_NewPermanentAtom(const nsAReadableString& aString); inline already_AddRefed do_GetAtom(const nsAReadableString& aString) { return NS_NewAtom(aString); } inline already_AddRefed do_GetPermanentAtom(const nsAReadableString& aString) { return NS_NewPermanentAtom(aString); } extern nsrefcnt NS_GetNumberOfAtoms(void); extern "C" { typedef struct PLHashEntry PLHashEntry; typedef struct PLHashTable PLHashTable; typedef PRUint32 PLHashNumber; typedef PLHashNumber ( *PLHashFunction)(const void *key); typedef PRIntn ( *PLHashComparator)(const void *v1, const void *v2); typedef PRIntn ( *PLHashEnumerator)(PLHashEntry *he, PRIntn i, void *arg); typedef struct PLHashAllocOps { void * ( *allocTable)(void *pool, PRSize size); void ( *freeTable)(void *pool, void *item); PLHashEntry * ( *allocEntry)(void *pool, const void *key); void ( *freeEntry)(void *pool, PLHashEntry *he, PRUintn flag); } PLHashAllocOps; struct PLHashEntry { PLHashEntry *next; PLHashNumber keyHash; const void *key; void *value; }; struct PLHashTable { PLHashEntry **buckets; PRUint32 nentries; PRUint32 shift; PLHashFunction keyHash; PLHashComparator keyCompare; PLHashComparator valueCompare; const PLHashAllocOps *allocOps; void *allocPool; }; extern PLHashTable * PL_NewHashTable(PRUint32 numBuckets, PLHashFunction keyHash, PLHashComparator keyCompare, PLHashComparator valueCompare, const PLHashAllocOps *allocOps, void *allocPool); extern void PL_HashTableDestroy(PLHashTable *ht); extern PLHashEntry * PL_HashTableAdd(PLHashTable *ht, const void *key, void *value); extern PRBool PL_HashTableRemove(PLHashTable *ht, const void *key); extern void * PL_HashTableLookup(PLHashTable *ht, const void *key); extern void * PL_HashTableLookupConst(PLHashTable *ht, const void *key); extern PRIntn PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg); extern PLHashNumber PL_HashString(const void *key); extern PRIntn PL_CompareStrings(const void *v1, const void *v2); extern PRIntn PL_CompareValues(const void *v1, const void *v2); extern PLHashEntry ** PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key); extern PLHashEntry ** PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash, const void *key); extern PLHashEntry * PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep, PLHashNumber keyHash, const void *key, void *value); extern void PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he); extern PRIntn PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp); } enum eCharSize {eOneByte=0,eTwoByte=1}; const PRInt32 kDefaultStringSize = 64; const PRInt32 kNotFound = -1; class CBufDescriptor { public: CBufDescriptor(char* aString, PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1); CBufDescriptor(const char* aString, PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1); CBufDescriptor(PRUnichar* aString, PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1); CBufDescriptor(const PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1); char* mBuffer; eCharSize mCharSize; PRUint32 mCapacity; PRInt32 mLength; PRBool mStackBased; PRBool mIsConst; }; struct nsStr { nsStr() { do { nsTraceRefcnt::LogCtor((void*)this, "nsStr", sizeof(*this)); } while (0); } ~nsStr() { do { nsTraceRefcnt::LogDtor((void*)this, "nsStr", sizeof(*this)); } while (0); } static void Initialize(nsStr& aDest,eCharSize aCharSize); static void Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer); static void Destroy(nsStr& aDest); static PRBool EnsureCapacity(nsStr& aString,PRUint32 aNewLength); static PRBool GrowCapacity(nsStr& aString,PRUint32 aNewLength); static void StrAppend(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount); static void StrAssign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount); static void StrInsert1into1( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); static void StrInsert1into2( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); static void StrInsert2into1( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); static void StrInsert2into2( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount); static PRInt32 GetSegmentLength(const nsStr& aSource, PRUint32 aSrcOffset, PRInt32 aCount); static void AppendForInsert(nsStr& aDest, PRUint32 aDestOffset, const nsStr& aSource, PRUint32 aSrcOffset, PRInt32 theLength); static void Delete1(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount); static void Delete2(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount); static PRInt32 GetDeleteLength(const nsStr& aDest, PRUint32 aDestOffset, PRUint32 aCount); static void StrTruncate(nsStr& aDest,PRUint32 aDestOffset); static void Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing); static void CompressSet1(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing); static void CompressSet2(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing); static void StripChars1(nsStr& aDest,const char* aSet); static void StripChars2(nsStr& aDest,const char* aSet); static PRInt32 StrCompare1To1(const nsStr& aDest,const nsStr& aSource, PRInt32 aCount,PRBool aIgnoreCase); static PRInt32 StrCompare1To2(const nsStr& aDest, const nsStr& aSource, PRInt32 aCount, PRBool aIgnoreCase); static PRInt32 StrCompare2To1(const nsStr& aDest, const nsStr& aSource, PRInt32 aCount, PRBool aIgnoreCase); static PRInt32 StrCompare2To2(const nsStr& aDest, const nsStr& aSource, PRInt32 aCount, PRBool aIgnoreCase); static PRInt32 FindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount); static PRInt32 FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount); static PRInt32 FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset); static PRInt32 RFindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount); static PRInt32 RFindChar1(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount); static PRInt32 RFindChar2(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount); static PRInt32 RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset); static void Overwrite(nsStr& aDest,const nsStr& aSource,PRInt32 anOffset); static PRBool DidAcquireMemory(void); static PRUint32 HashCode(const nsStr& aDest); protected: PRUint32 mLength; PRUint32 mCapacity; union { char* mStr; PRUnichar* mUStr; }; PRInt8 mCharSize; PRPackedBool mOwnsBuffer; private: static PRBool Alloc(nsStr& aString,PRUint32 aCount); static PRBool Realloc(nsStr& aString,PRUint32 aCount); static PRBool Free(nsStr& aString); public: friend inline void AddNullTerminator(nsStr& aDest); friend inline PRUnichar GetCharAt(const nsStr& aDest,PRUint32 anIndex); friend class nsString; friend class nsCString; }; inline PRInt32 MinInt(PRInt32 anInt1,PRInt32 anInt2){ return (anInt1* GetFlatBufferHandle() const; virtual const PRUnichar* GetReadableFragment( nsReadableFragment&, nsFragmentRequest, PRUint32 ) const; virtual PRUnichar* GetWritableFragment( nsWritableFragment&, nsFragmentRequest, PRUint32 ); public: virtual const PRUnichar* get() const; public: nsString(); nsString(const nsString& aString); explicit nsString(const nsAString&); explicit nsString(const PRUnichar*); nsString(const PRUnichar*, PRInt32); virtual ~nsString(); virtual PRUint32 Length() const { return mLength; } void SetLength(PRUint32 aLength); void SetCapacity(PRUint32 aLength); PRBool SetCharAt(PRUnichar aChar,PRUint32 anIndex); void StripChars( const char* aSet ); void StripChar( PRUnichar aChar, PRInt32 anOffset=0 ); void StripChar( char aChar, PRInt32 anOffset=0 ) { StripChar((PRUnichar) (unsigned char)aChar,anOffset); } void StripChar( PRInt32 anInt, PRInt32 anOffset=0 ) { StripChar((PRUnichar)anInt,anOffset); } void StripWhitespace(); void ReplaceChar( PRUnichar anOldChar, PRUnichar aNewChar ); void ReplaceChar( const char* aSet, PRUnichar aNewChar ); void ReplaceSubstring( const nsString& aTarget, const nsString& aNewValue ); void ReplaceSubstring( const PRUnichar* aTarget, const PRUnichar* aNewValue ); void Trim(const char* aSet,PRBool aEliminateLeading=1,PRBool aEliminateTrailing=1,PRBool aIgnoreQuotes=0); void CompressSet(const char* aSet, PRUnichar aChar,PRBool aEliminateLeading=1,PRBool aEliminateTrailing=1); void CompressWhitespace( PRBool aEliminateLeading=1,PRBool aEliminateTrailing=1); char* ToCString(char* aBuf,PRUint32 aBufLength,PRUint32 anOffset=0) const; float ToFloat(PRInt32* aErrorCode) const; PRInt32 ToInteger(PRInt32* aErrorCode,PRUint32 aRadix=(10)) const; nsString& operator=( const nsString& aString ) { Assign(aString); return *this; } nsString& operator=( const nsAString& aReadable ) { Assign(aReadable); return *this; } nsString& operator=( const PRUnichar* aPtr ) { Assign(aPtr); return *this; } nsString& operator=( PRUnichar aChar ) { Assign(aChar); return *this; } void AssignWithConversion(char); void AssignWithConversion(const char*); void AssignWithConversion(const char*, PRInt32); void AppendInt(PRInt32, PRInt32=10); void AppendFloat(double); void AppendWithConversion(const char*, PRInt32=-1); void AppendWithConversion(char); virtual void do_AppendFromElement( PRUnichar ); void InsertWithConversion(const char*, PRUint32, PRInt32=-1); void Adopt( PRUnichar* aPtr, PRInt32 aLength = -1 ); PRInt32 Find(const nsString& aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 Find(const nsStr& aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 Find(const char* aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 Find(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 FindChar(PRUnichar aChar,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=0) const; PRInt32 FindCharInSet(const PRUnichar* aString,PRInt32 anOffset=0) const; PRInt32 FindCharInSet(const nsStr& aString,PRInt32 anOffset=0) const; PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFind(const nsString& aString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFind(const nsStr& aString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFindChar(PRUnichar aChar,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFindCharInSet(const char* aString,PRInt32 anOffset=-1) const; PRInt32 RFindCharInSet(const PRUnichar* aString,PRInt32 anOffset=-1) const; PRInt32 RFindCharInSet(const nsStr& aString,PRInt32 anOffset=-1) const; PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRInt32 CompareWithConversion(const nsString& aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; inline PRInt32 CompareWithConversion(const nsXPIDLString& aString, PRBool aIgnoreCase=0, PRInt32 aCount=-1) const { return CompareWithConversion(aString.get(), aIgnoreCase, aCount); } PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; inline PRBool EqualsWithConversion(const nsXPIDLString &aString, PRBool aIgnoreCase=0, PRInt32 aCount=-1) const { return EqualsWithConversion(aString.get(), aIgnoreCase, aCount); } PRBool EqualsAtom( nsIAtom* anAtom,PRBool aIgnoreCase) const; PRBool EqualsIgnoreCase(const nsString& aString) const; PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; PRBool EqualsIgnoreCase( nsIAtom *aAtom) const; PRBool IsASCII(const PRUnichar* aBuffer=0); static PRBool IsSpace(PRUnichar ch); static PRBool IsAlpha(PRUnichar ch); static PRBool IsDigit(PRUnichar ch); virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; private: void operator=( char ); void AssignWithConversion( PRUnichar ); void AssignWithConversion( const PRUnichar*, PRInt32=-1 ); void AppendWithConversion( PRUnichar ); void AppendWithConversion( const PRUnichar*, PRInt32=-1 ); void InsertWithConversion( const PRUnichar*, PRUint32, PRInt32=-1 ); }; class nsAutoString : public nsString { public: virtual ~nsAutoString(); nsAutoString(); nsAutoString(const nsAutoString& aString); explicit nsAutoString(const nsAString& aString); explicit nsAutoString(const nsString& aString); explicit nsAutoString(const PRUnichar* aString); nsAutoString(const PRUnichar* aString,PRInt32 aLength); explicit nsAutoString(PRUnichar aChar); explicit nsAutoString(const CBufDescriptor& aBuffer); nsAutoString& operator=( const nsAutoString& aString ) { Assign(aString); return *this; } private: void operator=( char ); public: nsAutoString& operator=( const nsAString& aReadable ) { Assign(aReadable); return *this; } nsAutoString& operator=( const PRUnichar* aPtr ) { Assign(aPtr); return *this; } nsAutoString& operator=( PRUnichar aChar ) { Assign(aChar); return *this; } virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; char mBuffer[kDefaultStringSize<* GetFlatBufferHandle() const; virtual const char* GetReadableFragment( nsReadableFragment&, nsFragmentRequest, PRUint32 ) const; virtual char* GetWritableFragment( nsWritableFragment&, nsFragmentRequest, PRUint32 ); public: virtual const char* get() const { return mStr; } public: nsCString(); nsCString(const nsCString& aString); explicit nsCString( const nsACString& ); explicit nsCString(const char*); nsCString(const char*, PRInt32); virtual ~nsCString(); virtual PRUint32 Length() const { return mLength; } void SetLength(PRUint32 aLength); void SetCapacity(PRUint32 aLength); PRBool SetCharAt(PRUnichar aChar,PRUint32 anIndex); void StripChars(const char* aSet); void StripChar(PRUnichar aChar,PRInt32 anOffset=0); void StripChar(char aChar,PRInt32 anOffset=0) { StripChar((PRUnichar) (unsigned char)aChar,anOffset); } void StripWhitespace(); void ReplaceChar(PRUnichar aOldChar,PRUnichar aNewChar); void ReplaceChar(const char* aSet,PRUnichar aNewChar); void ReplaceSubstring(const nsCString& aTarget,const nsCString& aNewValue); void ReplaceSubstring(const char* aTarget,const char* aNewValue); void Trim(const char* aSet,PRBool aEliminateLeading=1,PRBool aEliminateTrailing=1,PRBool aIgnoreQuotes=0); void CompressSet(const char* aSet, PRUnichar aChar,PRBool aEliminateLeading=1,PRBool aEliminateTrailing=1); void CompressWhitespace( PRBool aEliminateLeading=1,PRBool aEliminateTrailing=1); float ToFloat(PRInt32* aErrorCode) const; PRInt32 ToInteger(PRInt32* aErrorCode,PRUint32 aRadix=(10)) const; nsCString& operator=( const nsCString& aString ) { Assign(aString); return *this; } nsCString& operator=( const nsACString& aReadable ) { Assign(aReadable); return *this; } nsCString& operator=( const char* aPtr ) { Assign(aPtr); return *this; } nsCString& operator=( char aChar ) { Assign(aChar); return *this; } void AssignWithConversion(const PRUnichar*,PRInt32=-1); void AssignWithConversion( const nsString& aString ); void AssignWithConversion( const nsAString& aString ); void AssignWithConversion(PRUnichar); void AppendWithConversion(const nsString&, PRInt32=-1); void AppendWithConversion(PRUnichar aChar); void AppendWithConversion( const nsAString& aString ); void AppendWithConversion(const PRUnichar*, PRInt32=-1); void AppendInt(PRInt32 aInteger,PRInt32 aRadix=10); void AppendFloat( double aFloat ); void InsertWithConversion(PRUnichar aChar,PRUint32 anOffset); void Adopt( char* aPtr, PRInt32 aLength = -1 ); PRInt32 Find(const nsStr& aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 Find(const char* aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 Find(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 FindChar(PRUnichar aChar,PRBool aIgnoreCase=0,PRInt32 anOffset=0,PRInt32 aCount=-1) const; PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=0) const; PRInt32 FindCharInSet(const PRUnichar* aString,PRInt32 anOffset=0) const; PRInt32 FindCharInSet(const nsStr& aString,PRInt32 anOffset=0) const; PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFind(const nsStr& aString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFindChar(PRUnichar aChar,PRBool aIgnoreCase=0,PRInt32 anOffset=-1,PRInt32 aCount=-1) const; PRInt32 RFindCharInSet(const char* aString,PRInt32 anOffset=-1) const; PRInt32 RFindCharInSet(const PRUnichar* aString,PRInt32 anOffset=-1) const; PRInt32 RFindCharInSet(const nsStr& aString,PRInt32 anOffset=-1) const; PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRBool EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRBool EqualsWithConversion(const char* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; PRBool EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=0,PRInt32 aCount=-1) const; inline PRBool EqualsWithConversion(const nsXPIDLString &aString, PRBool aIgnoreCase=0, PRInt32 aCount=-1) const { return EqualsWithConversion(aString.get(), aIgnoreCase, aCount); } PRBool EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const; PRBool EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const; virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; private: void operator=( PRUnichar ); void AssignWithConversion( char ); void AssignWithConversion( const char*, PRInt32=-1 ); void AppendWithConversion( char ); void InsertWithConversion( char, PRUint32 ); }; class nsCAutoString : public nsCString { public: virtual ~nsCAutoString(); nsCAutoString(); explicit nsCAutoString(const nsCString& ); explicit nsCAutoString(const nsACString& aString); explicit nsCAutoString(const char* aString); nsCAutoString(const char* aString,PRInt32 aLength); explicit nsCAutoString(const CBufDescriptor& aBuffer); nsCAutoString& operator=( const nsCAutoString& aString ) { Assign(aString); return *this; } private: void operator=( PRUnichar ); public: nsCAutoString& operator=( const nsACString& aReadable ) { Assign(aReadable); return *this; } nsCAutoString& operator=( const char* aPtr ) { Assign(aPtr); return *this; } nsCAutoString& operator=( char aChar ) { Assign(aChar); return *this; } virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; char mBuffer[kDefaultStringSize]; }; class NS_ConvertUCS2toUTF8 : public nsCAutoString { public: friend char* ToNewUTF8String( const nsAString& aSource ); public: explicit NS_ConvertUCS2toUTF8( const PRUnichar* aString ) { Append( aString, ~PRUint32(0) ); } NS_ConvertUCS2toUTF8( const PRUnichar* aString, PRUint32 aLength ) { Append( aString, aLength ); } explicit NS_ConvertUCS2toUTF8( const nsAString& aString ); protected: void Append( const PRUnichar* aString, PRUint32 aLength ); private: NS_ConvertUCS2toUTF8( char ); }; class NS_LossyConvertUCS2toASCII : public nsCAutoString { public: explicit NS_LossyConvertUCS2toASCII( const PRUnichar* aString ) { AppendWithConversion( aString, ~PRUint32(0) ); } NS_LossyConvertUCS2toASCII( const PRUnichar* aString, PRUint32 aLength ) { AppendWithConversion( aString, aLength ); } explicit NS_LossyConvertUCS2toASCII( const nsAString& aString ); private: NS_LossyConvertUCS2toASCII( char ); }; class nsAString; class nsACString; class nsAStringGenerator { public: virtual ~nsAStringGenerator() { } virtual PRUnichar* operator()( PRUnichar* aDestBuffer ) const = 0; virtual PRUint32 Length() const = 0; virtual PRUint32 MaxLength() const = 0; virtual PRBool IsDependentOn( const nsAString& ) const = 0; }; class nsACStringGenerator { public: virtual ~nsACStringGenerator() { } virtual char* operator()( char* aDestBuffer ) const = 0; virtual PRUint32 Length() const = 0; virtual PRUint32 MaxLength() const = 0; virtual PRBool IsDependentOn( const nsACString& ) const = 0; }; class nsASingleFragmentCString; class nsCString; size_t Distance( const nsAString::const_iterator&, const nsAString::const_iterator& ); size_t Distance( const nsACString::const_iterator&, const nsACString::const_iterator& ); void CopyUCS2toASCII( const nsAString& aSource, nsACString& aDest ); void CopyASCIItoUCS2( const nsACString& aSource, nsAString& aDest ); char* ToNewCString( const nsAString& aSource ); char* ToNewCString( const nsACString& aSource ); char* ToNewUTF8String( const nsAString& aSource ); PRUnichar* ToNewUnicode( const nsAString& aSource ); PRUnichar* ToNewUnicode( const nsACString& aSource ); PRUnichar* CopyUnicodeTo( const nsAString& aSource, PRUint32 aSrcOffset, PRUnichar* aDest, PRUint32 aLength ); void CopyUnicodeTo( const nsAString::const_iterator& aSrcStart, const nsAString::const_iterator& aSrcEnd, nsAString& aDest ); void AppendUnicodeTo( const nsAString::const_iterator& aSrcStart, const nsAString::const_iterator& aSrcEnd, nsAString& aDest ); PRBool IsASCII( const nsAString& aString ); void ToUpperCase( nsACString& ); void ToLowerCase( nsACString& ); void ToUpperCase( nsASingleFragmentCString& ); void ToLowerCase( nsASingleFragmentCString& ); void ToUpperCase( nsCString& ); void ToLowerCase( nsCString& ); void ToUpperCase( const nsACString& aSource, nsACString& aDest ); void ToLowerCase( const nsACString& aSource, nsACString& aDest ); PRBool FindInReadable( const nsAString& aPattern, nsAString::const_iterator&, nsAString::const_iterator&, const nsStringComparator& = nsDefaultStringComparator() ); PRBool FindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator&, const nsCStringComparator& = nsDefaultCStringComparator() ); PRBool CaseInsensitiveFindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator& ); PRBool RFindInReadable( const nsAString& aPattern, nsAString::const_iterator&, nsAString::const_iterator& ); PRBool RFindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator& ); PRBool FindCharInReadable( PRUnichar aChar, nsAString::const_iterator& aSearchStart, const nsAString::const_iterator& aSearchEnd ); PRBool FindCharInReadable( char aChar, nsACString::const_iterator& aSearchStart, const nsACString::const_iterator& aSearchEnd ); PRUint32 CountCharInReadable( const nsAString& aStr, PRUnichar aChar ); PRUint32 CountCharInReadable( const nsACString& aStr, char aChar ); PRUint32 HashString( const nsAString& aStr ); PRUint32 HashString( const nsACString& aStr ); class nsSubstituteString : public nsAStringGenerator { public: nsSubstituteString( const nsAString& aText, const nsAString& aPattern, const nsAString& aReplacement ) : mText(aText), mPattern(aPattern), mReplacement(aReplacement), mNumberOfMatches(-1) { } virtual PRUnichar* operator()( PRUnichar* aDestBuffer ) const; virtual PRUint32 Length() const; virtual PRUint32 MaxLength() const; virtual PRBool IsDependentOn( const nsAString& ) const; private: void CountMatches() const; private: const nsAString& mText; const nsAString& mPattern; const nsAString& mReplacement; PRInt32 mNumberOfMatches; }; class nsSubstituteCString : public nsACStringGenerator { public: nsSubstituteCString( const nsACString& aText, const nsACString& aPattern, const nsACString& aReplacement ) : mText(aText), mPattern(aPattern), mReplacement(aReplacement), mNumberOfMatches(-1) { } virtual char* operator()( char* aDestBuffer ) const; virtual PRUint32 Length() const; virtual PRUint32 MaxLength() const; virtual PRBool IsDependentOn( const nsACString& ) const; private: void CountMatches() const; private: const nsACString& mText; const nsACString& mPattern; const nsACString& mReplacement; PRInt32 mNumberOfMatches; }; class nsILocalFile : public nsIFile { public: static const nsIID& GetIID() {static const nsIID iid = {0xaa610f20, 0xa889, 0x11d3, { 0x8c, 0x81, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}; return iid;} virtual nsresult InitWithPath(const char *filePath) = 0; virtual nsresult InitWithUnicodePath(const PRUnichar *filePath) = 0; virtual nsresult GetFollowLinks(PRBool *aFollowLinks) = 0; virtual nsresult SetFollowLinks(PRBool aFollowLinks) = 0; virtual nsresult OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc * *_retval) = 0; virtual nsresult OpenANSIFileDesc(const char *mode, FILE * *_retval) = 0; virtual nsresult Load(PRLibrary * *_retval) = 0; virtual nsresult GetDiskSpaceAvailable(PRInt64 *aDiskSpaceAvailable) = 0; virtual nsresult AppendRelativePath(const char *relativeFilePath) = 0; virtual nsresult AppendRelativeUnicodePath(const PRUnichar *relativeFilePath) = 0; virtual nsresult GetPersistentDescriptor(char * *aPersistentDescriptor) = 0; virtual nsresult SetPersistentDescriptor(const char * aPersistentDescriptor) = 0; virtual nsresult Reveal(void) = 0; virtual nsresult Launch(void) = 0; }; extern "C" nsresult NS_NewLocalFile(const char* path, PRBool followLinks, nsILocalFile* *result); extern "C" nsresult NS_NewUnicodeLocalFile(const PRUnichar* path, PRBool followLinks, nsILocalFile* *result); extern "C" { #ident "$Revision: 1.35 $" extern "C" { #ident "$Revision: 3.21 $" typedef struct dirent { ino_t d_ino; off_t d_off; unsigned short d_reclen; char d_name[1]; } dirent_t; typedef struct dirent64 { ino_t d_ino; off_t d_off; unsigned short d_reclen; char d_name[1]; } dirent64_t; extern int getdents(int, dirent_t *, unsigned); extern int getdents64(int, dirent64_t *, unsigned); extern int ngetdents(int, dirent_t *, unsigned, int *); extern int ngetdents64(int, dirent64_t *, unsigned, int *); } typedef struct { int __dd_fd; int __dd_loc; int __dd_size; char *__dd_buf; int __dd_flags; } DIR; extern DIR *opendir( const char * ); extern int closedir( DIR * ); extern dirent_t *readdir( DIR * ); extern void rewinddir( DIR * ); extern off_t telldir( DIR * ); extern void seekdir( DIR *, off_t ); extern int scandir(const char *, dirent_t **[], int (*)(dirent_t *), int (*)(dirent_t **, dirent_t **)); extern int alphasort(dirent_t **, dirent_t **); extern int scandir64(const char *, dirent64_t **[], int (*)(dirent64_t *), int (*)(dirent64_t **, dirent64_t **)); extern int alphasort64(dirent64_t **, dirent64_t **); extern int readdir64_r(DIR *, dirent64_t *, dirent64_t **); extern off64_t telldir64(DIR *); extern void seekdir64(DIR *, off64_t); extern dirent64_t *readdir64(DIR *); extern int readdir_r(DIR *, dirent_t *, dirent_t **); } class nsFileSpec; class nsFilePath; class nsFileURL; class nsNSPRPath; class nsPersistentFileDescriptor; class nsOutputStream; class nsInputStream; class nsIOutputStream; class nsIInputStream; class nsOutputFileStream; class nsInputFileStream; class nsOutputConsoleStream; class nsString; class nsIUnicodeEncoder; class nsIUnicodeDecoder; nsresult ns_file_convert_result(PRInt32 nativeErr); class nsSimpleCharString { public: nsSimpleCharString(); nsSimpleCharString(const char*); nsSimpleCharString(const nsString&); nsSimpleCharString(const nsSimpleCharString&); nsSimpleCharString(const char* inData, PRUint32 inLength); ~nsSimpleCharString(); void operator = (const char*); void operator = (const nsString&); void operator = (const nsSimpleCharString&); operator const char*() const { return mData ? mData->mString : 0; } operator char* () { ReallocData(Length()); return mData ? mData->mString : 0; } PRBool operator == (const char*); PRBool operator == (const nsString&); PRBool operator == (const nsSimpleCharString&); void operator += (const char* inString); nsSimpleCharString operator + (const char* inString) const; char operator [](int i) const { return mData ? mData->mString[i] : '\0'; } char& operator [](int i) { if (i >= (int)Length()) ReallocData((PRUint32)i + 1); return mData->mString[i]; } char& operator [](unsigned int i) { return (*this)[(int)i]; } void Catenate(const char* inString1, const char* inString2); void SetToEmpty(); PRBool IsEmpty() const { return Length() == 0; } PRUint32 Length() const { return mData ? mData->mLength : 0; } void SetLength(PRUint32 inLength) { ReallocData(inLength); } void CopyFrom(const char* inData, PRUint32 inLength); void LeafReplace(char inSeparator, const char* inLeafName); char* GetLeaf(char inSeparator) const; void Unescape(); protected: void AddRefData(); void ReleaseData(); void ReallocData(PRUint32 inLength); protected: struct Data { int mRefCount; PRUint32 mLength; char mString[1]; }; Data* mData; }; class nsFileSpec { public: nsFileSpec(); nsFileSpec(const char* inNativePath, PRBool inCreateDirs = 0); nsFileSpec(const nsString& inNativePath, PRBool inCreateDirs = 0); nsFileSpec(const nsFilePath& inPath); nsFileSpec(const nsFileURL& inURL); nsFileSpec(const nsPersistentFileDescriptor& inURL); nsFileSpec(const nsFileSpec& inPath); virtual ~nsFileSpec(); void operator = (const char* inNativePath); void operator = (const nsFilePath& inPath); void operator = (const nsFileURL& inURL); void operator = (const nsFileSpec& inOther); void operator = (const nsPersistentFileDescriptor& inOther); PRBool operator ==(const nsFileSpec& inOther) const; PRBool operator !=(const nsFileSpec& inOther) const; const char* GetCString() const; operator const char* () const { return GetCString(); } const char* GetNativePathCString() const { return GetCString(); } PRBool IsChildOf(nsFileSpec &possibleParent); PRBool Valid() const { return (!((Error()) & 0x80000000)); } nsresult Error() const { if (mPath.IsEmpty() && (!((mError) & 0x80000000))) ((nsFileSpec*)this)->mError = (((nsresult) 0xC1F30000) + 1); return mError; } PRBool Failed() const { return (PRBool)((Error()) & 0x80000000); } char* GetLeafName() const; void SetLeafName(const char* inLeafName); void GetParent(nsFileSpec& outSpec) const; typedef PRUint32 TimeStamp; void GetModDate(TimeStamp& outStamp) const; PRBool ModDateChanged(const TimeStamp& oldStamp) const { TimeStamp newStamp; GetModDate(newStamp); return newStamp != oldStamp; } PRUint32 GetFileSize() const; PRInt64 GetDiskSpaceAvailable() const; nsFileSpec operator + (const char* inRelativeUnixPath) const; void operator += (const char* inRelativeUnixPath); void MakeUnique(); void MakeUnique(const char* inSuggestedLeafName); PRBool IsDirectory() const; PRBool IsFile() const; PRBool Exists() const; PRBool IsHidden() const; PRBool IsSymlink() const; nsresult ResolveSymlink(PRBool& wasSymlink); void CreateDirectory(int mode = 0775 ); void CreateDir(int mode = 0775) { CreateDirectory(mode); } void Delete(PRBool inRecursive) const; nsresult Truncate(PRInt32 aNewLength) const; void RecursiveCopy(nsFileSpec newDir) const; nsresult Rename(const char* inNewName); nsresult CopyToDir(const nsFileSpec& inNewParentDirectory) const; nsresult MoveToDir(const nsFileSpec& inNewParentDirectory); nsresult Execute(const char* args) const; protected: protected: void Clear(); friend class nsFilePath; friend class nsFileURL; friend class nsDirectoryIterator; nsSimpleCharString mPath; nsresult mError; }; typedef nsFileSpec nsNativeFileSpec; class nsFileURL { public: nsFileURL(const nsFileURL& inURL); nsFileURL(const char* inURLString, PRBool inCreateDirs = 0); nsFileURL(const nsString& inURLString, PRBool inCreateDirs = 0); nsFileURL(const nsFilePath& inPath); nsFileURL(const nsFileSpec& inPath); virtual ~nsFileURL(); void operator = (const nsFileURL& inURL); void operator = (const char* inURLString); void operator = (const nsString& inURLString) { *this = NS_LossyConvertUCS2toASCII(inURLString).get(); } void operator = (const nsFilePath& inOther); void operator = (const nsFileSpec& inOther); void operator +=(const char* inRelativeUnixPath); nsFileURL operator +(const char* inRelativeUnixPath) const; operator const char* () const { return (const char*)mURL; } const char* GetURLString() const { return (const char*)mURL; } const char* GetAsString() const { return (const char*)mURL; } protected: friend class nsFilePath; nsSimpleCharString mURL; }; class nsFilePath { public: nsFilePath(const nsFilePath& inPath); nsFilePath(const char* inUnixPathString, PRBool inCreateDirs = 0); nsFilePath(const nsString& inUnixPathString, PRBool inCreateDirs = 0); nsFilePath(const nsFileURL& inURL); nsFilePath(const nsFileSpec& inPath); virtual ~nsFilePath(); operator const char* () const { return mPath; } void operator = (const nsFilePath& inPath); void operator = (const char* inUnixPathString); void operator = (const nsString& inUnixPathString) { *this = NS_LossyConvertUCS2toASCII(inUnixPathString).get(); } void operator = (const nsFileURL& inURL); void operator = (const nsFileSpec& inOther); void operator +=(const char* inRelativeUnixPath); nsFilePath operator +(const char* inRelativeUnixPath) const; private: nsSimpleCharString mPath; }; class nsPersistentFileDescriptor { public: nsPersistentFileDescriptor() {} nsPersistentFileDescriptor(const nsPersistentFileDescriptor& inEncodedData); virtual ~nsPersistentFileDescriptor(); void operator = (const nsPersistentFileDescriptor& inEncodedData); nsPersistentFileDescriptor(const nsFileSpec& inSpec); void operator = (const nsFileSpec& inSpec); friend nsresult Read(nsIInputStream* aStream, nsPersistentFileDescriptor&); friend nsresult Write(nsIOutputStream* aStream, const nsPersistentFileDescriptor&); friend nsInputStream& operator >> (nsInputStream&, nsPersistentFileDescriptor&); friend nsOutputStream& operator << (nsOutputStream&, const nsPersistentFileDescriptor&); friend class nsFileSpec; void GetData(nsSimpleCharString& outData) const; void SetData(const nsSimpleCharString& inData); void GetData(nsSimpleCharString& outData, PRInt32& outSize) const; void SetData(const nsSimpleCharString& inData, PRInt32 inSize); void SetData(const char* inData, PRInt32 inSize); protected: nsSimpleCharString mDescriptorString; }; class nsDirectoryIterator { public: nsDirectoryIterator( const nsFileSpec& parent, PRBool resoveSymLinks); virtual ~nsDirectoryIterator(); PRBool Exists() const { return mExists; } nsDirectoryIterator& operator ++(); nsDirectoryIterator& operator ++(int) { return ++(*this); } nsDirectoryIterator& operator --(); nsDirectoryIterator& operator --(int) { return --(*this); } operator nsFileSpec&() { return mCurrent; } nsFileSpec& Spec() { return mCurrent; } private: private: nsFileSpec mCurrent; PRBool mExists; PRBool mResoveSymLinks; nsFileSpec mStarting; DIR* mDir; }; class nsNSPRPath { public: nsNSPRPath(const nsFileSpec& inSpec) : mFilePath(inSpec), modifiedNSPRPath(0) {} nsNSPRPath(const nsFileURL& inURL) : mFilePath(inURL), modifiedNSPRPath(0) {} nsNSPRPath(const nsFilePath& inUnixPath) : mFilePath(inUnixPath), modifiedNSPRPath(0) {} virtual ~nsNSPRPath(); operator const char*() const; private: nsFilePath mFilePath; char* modifiedNSPRPath; }; nsresult NS_FileSpecToIFile(nsFileSpec* fileSpec, nsILocalFile* *result); class nsISizeOfHandler; typedef int (* nsVoidArrayComparatorFunc) (const void* aElement1, const void* aElement2, void* aData); typedef PRBool (* nsVoidArrayEnumFunc)(void* aElement, void *aData); class nsVoidArray { public: nsVoidArray(); nsVoidArray(PRInt32 aCount); virtual ~nsVoidArray(); nsVoidArray& operator=(const nsVoidArray& other); virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; inline PRInt32 Count() const { return mImpl ? mImpl->mCount : 0; } inline PRInt32 GetArraySize() const { return mImpl ? PRInt32(mImpl->mBits & kArraySizeMask) : 0; } void* ElementAt(PRInt32 aIndex) const { if (!(aIndex >= 0)) nsDebug::Assertion("nsVoidArray::ElementAt(negative index) - note on bug 96108", "aIndex >= 0", "../../dist/include/xpcom/nsVoidArray.h", 77); if (!(aIndex < Count())) nsDebug::Assertion("nsVoidArray::ElementAt(index past end array) - note on bug 96108", "aIndex < Count()", "../../dist/include/xpcom/nsVoidArray.h", 78); if (aIndex >= Count()) { return 0; } return mImpl->mArray[aIndex]; } void* SafeElementAt(PRInt32 aIndex) const { if (aIndex < 0 || aIndex >= Count()) { return 0; } return mImpl->mArray[aIndex]; } void* operator[](PRInt32 aIndex) const { return ElementAt(aIndex); } PRInt32 IndexOf(void* aPossibleElement) const; PRBool InsertElementAt(void* aElement, PRInt32 aIndex); PRBool InsertElementsAt(const nsVoidArray &other, PRInt32 aIndex); PRBool ReplaceElementAt(void* aElement, PRInt32 aIndex); PRBool MoveElement(PRInt32 aFrom, PRInt32 aTo); PRBool AppendElement(void* aElement) { return InsertElementAt(aElement, Count()); } PRBool AppendElements(nsVoidArray& aElements) { return InsertElementsAt(aElements, Count()); } PRBool RemoveElement(void* aElement); PRBool RemoveElementsAt(PRInt32 aIndex, PRInt32 aCount); PRBool RemoveElementAt(PRInt32 aIndex) { return RemoveElementsAt(aIndex,1); } virtual void Clear(); virtual PRBool SizeTo(PRInt32 aMin); virtual void Compact(); void Sort(nsVoidArrayComparatorFunc aFunc, void* aData); PRBool EnumerateForwards(nsVoidArrayEnumFunc aFunc, void* aData); PRBool EnumerateBackwards(nsVoidArrayEnumFunc aFunc, void* aData); protected: virtual PRBool GrowArrayBy(PRInt32 aGrowBy); struct Impl { PRUint32 mBits; PRInt32 mCount; void* mArray[1]; }; Impl* mImpl; enum { kArrayOwnerMask = 1 << 31, kArraySizeMask = ~kArrayOwnerMask }; void SetArray(Impl *newImpl, PRInt32 aSize, PRInt32 aCount, PRBool owner); inline PRBool IsArrayOwner() const { return mImpl ? PRBool(mImpl->mBits & kArrayOwnerMask) : 0; } private: nsVoidArray(const nsVoidArray& other); }; class nsAutoVoidArray : public nsVoidArray { public: nsAutoVoidArray(); void Clear(); virtual PRBool SizeTo(PRInt32 aMin); virtual void Compact(); protected: enum { kAutoBufSize = 8 }; char mAutoBuf[sizeof(Impl) + (kAutoBufSize - 1) * sizeof(void*)]; }; class nsString; typedef int (* nsStringArrayComparatorFunc) (const nsString* aElement1, const nsString* aElement2, void* aData); typedef PRBool (*nsStringArrayEnumFunc)(nsString& aElement, void *aData); class nsStringArray: protected nsVoidArray { public: nsStringArray(void); nsStringArray(PRInt32 aCount); virtual ~nsStringArray(void); nsStringArray& operator=(const nsStringArray& other); void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; PRInt32 Count(void) const { return nsVoidArray::Count(); } void StringAt(PRInt32 aIndex, nsAWritableString& aString) const; nsString* StringAt(PRInt32 aIndex) const; nsString* operator[](PRInt32 aIndex) const { return StringAt(aIndex); } PRInt32 IndexOf(const nsAReadableString& aPossibleString) const; PRBool InsertStringAt(const nsAReadableString& aString, PRInt32 aIndex); PRBool ReplaceStringAt(const nsAReadableString& aString, PRInt32 aIndex); PRBool AppendString(const nsAReadableString& aString) { return InsertStringAt(aString, Count()); } PRBool RemoveString(const nsAReadableString& aString); PRBool RemoveStringAt(PRInt32 aIndex); void Clear(void); void Compact(void) { nsVoidArray::Compact(); } void Sort(void); void Sort(nsStringArrayComparatorFunc aFunc, void* aData); PRBool EnumerateForwards(nsStringArrayEnumFunc aFunc, void* aData); PRBool EnumerateBackwards(nsStringArrayEnumFunc aFunc, void* aData); private: nsStringArray(const nsStringArray& other); }; class nsCString; typedef int (* nsCStringArrayComparatorFunc) (const nsCString* aElement1, const nsCString* aElement2, void* aData); typedef PRBool (*nsCStringArrayEnumFunc)(nsCString& aElement, void *aData); class nsCStringArray: protected nsVoidArray { public: nsCStringArray(void); nsCStringArray(PRInt32 aCount); virtual ~nsCStringArray(void); nsCStringArray& operator=(const nsCStringArray& other); void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; PRInt32 Count(void) const { return nsVoidArray::Count(); } void CStringAt(PRInt32 aIndex, nsCString& aCString) const; nsCString* CStringAt(PRInt32 aIndex) const; nsCString* operator[](PRInt32 aIndex) const { return CStringAt(aIndex); } PRInt32 IndexOf(const nsCString& aPossibleString) const; PRInt32 IndexOfIgnoreCase(const nsCString& aPossibleString) const; PRBool InsertCStringAt(const nsCString& aCString, PRInt32 aIndex); PRBool ReplaceCStringAt(const nsCString& aCString, PRInt32 aIndex); PRBool AppendCString(const nsCString& aCString) { return InsertCStringAt(aCString, Count()); } PRBool RemoveCString(const nsCString& aCString); PRBool RemoveCStringIgnoreCase(const nsCString& aCString); PRBool RemoveCStringAt(PRInt32 aIndex); void Clear(void); void Compact(void) { nsVoidArray::Compact(); } void Sort(void); void SortIgnoreCase(void); void Sort(nsCStringArrayComparatorFunc aFunc, void* aData); PRBool EnumerateForwards(nsCStringArrayEnumFunc aFunc, void* aData); PRBool EnumerateBackwards(nsCStringArrayEnumFunc aFunc, void* aData); private: nsCStringArray(const nsCStringArray& other); }; class nsSmallVoidArray { public: nsSmallVoidArray(); ~nsSmallVoidArray(); nsSmallVoidArray& operator=(nsSmallVoidArray& other); void* operator[](PRInt32 aIndex) const { return ElementAt(aIndex); } void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const; PRInt32 GetArraySize() const; PRInt32 Count() const; void* ElementAt(PRInt32 aIndex) const; void* SafeElementAt(PRInt32 aIndex) const { if (aIndex < 0 || aIndex >= Count()) return 0; return ElementAt(aIndex); } PRInt32 IndexOf(void* aPossibleElement) const; PRBool InsertElementAt(void* aElement, PRInt32 aIndex); PRBool InsertElementsAt(const nsVoidArray &other, PRInt32 aIndex); PRBool ReplaceElementAt(void* aElement, PRInt32 aIndex); PRBool MoveElement(PRInt32 aFrom, PRInt32 aTo); PRBool AppendElement(void* aElement); PRBool AppendElements(nsVoidArray& aElements) { return InsertElementsAt(aElements, Count()); } PRBool RemoveElement(void* aElement); PRBool RemoveElementsAt(PRInt32 aIndex, PRInt32 aCount); PRBool RemoveElementAt(PRInt32 aIndex); void Clear(); PRBool SizeTo(PRInt32 aMin); void Compact(); void Sort(nsVoidArrayComparatorFunc aFunc, void* aData); PRBool EnumerateForwards(nsVoidArrayEnumFunc aFunc, void* aData); PRBool EnumerateBackwards(nsVoidArrayEnumFunc aFunc, void* aData); private: typedef unsigned long PtrBits; PRBool HasSingleChild() const { return (mChildren && (PtrBits(mChildren) & 0x1)); } PRBool HasVector() const { return (mChildren && !(PtrBits(mChildren) & 0x1)); } void* GetSingleChild() const { return (mChildren ? ((void*)(PtrBits(mChildren) & ~0x1)) : 0); } void SetSingleChild(void *aChild); nsVoidArray* GetChildVector() const { return (nsVoidArray*)mChildren; } nsVoidArray* SwitchToVector(); void *mChildren; }; class nsIObjectInputStream; class nsIObjectOutputStream; class nsHashtable; class nsStringKey; class nsHashKey { protected: nsHashKey(void) { mKeyType = UnknownKey; do { nsTraceRefcnt::LogCtor((void*)this, "nsHashKey", sizeof(*this)); } while (0); } public: virtual ~nsHashKey(void); virtual PRUint32 HashCode(void) const = 0; virtual PRBool Equals(const nsHashKey *aKey) const = 0; virtual nsHashKey *Clone() const = 0; virtual nsresult Write(nsIObjectOutputStream* aStream) const; public: enum nsHashKeyType { UnknownKey, SupportsKey, PRUint32Key, VoidKey, IDKey, CStringKey, StringKey, OpaqueKey }; nsHashKeyType GetKeyType() const { return mKeyType; } protected: nsHashKeyType mKeyType; }; typedef PRBool (* nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* aClosure); typedef nsresult (* nsHashtableReadEntryFunc)(nsIObjectInputStream *aStream, nsHashKey **aKey, void **aData); typedef void (* nsHashtableFreeEntryFunc)(nsIObjectInputStream *aStream, nsHashKey *aKey, void *aData); typedef nsresult (* nsHashtableWriteDataFunc)(nsIObjectOutputStream *aStream, void *aData); class nsHashtable { protected: PRLock* mLock; PLHashTable mHashtable; PRBool mEnumerating; public: nsHashtable(PRUint32 aSize = 16, PRBool threadSafe = 0); virtual ~nsHashtable(); PRInt32 Count(void) { return mHashtable.nentries; } PRBool Exists(nsHashKey *aKey); void *Put(nsHashKey *aKey, void *aData); void *Get(nsHashKey *aKey); void *Remove(nsHashKey *aKey); nsHashtable *Clone(); void Enumerate(nsHashtableEnumFunc aEnumFunc, void* aClosure = __null); void Reset(); void Reset(nsHashtableEnumFunc destroyFunc, void* aClosure = __null); nsHashtable(nsIObjectInputStream* aStream, nsHashtableReadEntryFunc aReadEntryFunc, nsHashtableFreeEntryFunc aFreeEntryFunc, nsresult *aRetVal); nsresult Write(nsIObjectOutputStream* aStream, nsHashtableWriteDataFunc aWriteDataFunc) const; }; typedef void* (* nsHashtableCloneElementFunc)(nsHashKey *aKey, void *aData, void* aClosure); class nsObjectHashtable : public nsHashtable { public: nsObjectHashtable(nsHashtableCloneElementFunc cloneElementFun, void* cloneElementClosure, nsHashtableEnumFunc destroyElementFun, void* destroyElementClosure, PRUint32 aSize = 16, PRBool threadSafe = 0); ~nsObjectHashtable(); nsHashtable *Clone(); void Reset(); PRBool RemoveAndDelete(nsHashKey *aKey); protected: static PRIntn CopyElement(PLHashEntry *he, PRIntn i, void *arg); nsHashtableCloneElementFunc mCloneElementFun; void* mCloneElementClosure; nsHashtableEnumFunc mDestroyElementFun; void* mDestroyElementClosure; }; class nsISupports; class nsSupportsHashtable : private nsHashtable { public: typedef PRBool (* EnumFunc) (nsHashKey *aKey, void *aData, void* aClosure); nsSupportsHashtable(PRUint32 aSize = 16, PRBool threadSafe = 0) : nsHashtable(aSize, threadSafe) {} ~nsSupportsHashtable(); PRInt32 Count(void) { return nsHashtable::Count(); } PRBool Exists(nsHashKey *aKey) { return nsHashtable::Exists (aKey); } PRBool Put(nsHashKey *aKey, nsISupports *aData, nsISupports **value = 0); nsISupports* Get(nsHashKey *aKey); PRBool Remove(nsHashKey *aKey, nsISupports **value = 0); nsHashtable *Clone(); void Enumerate(EnumFunc aEnumFunc, void* aClosure = __null) { nsHashtable::Enumerate(aEnumFunc, aClosure); } void Reset(); private: static PRBool ReleaseElement(nsHashKey *, void *, void *); static PRIntn EnumerateCopy(PLHashEntry *, PRIntn, void *); }; class nsISupportsKey : public nsHashKey { protected: nsISupports* mKey; public: nsISupportsKey(nsISupports* key) { mKeyType = SupportsKey; mKey = key; ((0 != (mKey)) ? ns_if_addref(mKey) : 0); } ~nsISupportsKey(void) { do { if (mKey) { (mKey)->Release(); (mKey) = 0; } } while (0); } PRUint32 HashCode(void) const { return ((char *)(mKey) - (char *)0); } PRBool Equals(const nsHashKey *aKey) const { if (!(aKey->GetKeyType() == SupportsKey)) nsDebug::Assertion("mismatched key types", "aKey->GetKeyType() == SupportsKey", "../../dist/include/xpcom/nsHashtable.h", 225); return (mKey == ((nsISupportsKey *) aKey)->mKey); } nsHashKey *Clone() const { return new nsISupportsKey(mKey); } nsISupportsKey(nsIObjectInputStream* aStream, nsresult *aResult); nsresult Write(nsIObjectOutputStream* aStream) const; }; class nsPRUint32Key : public nsHashKey { protected: PRUint32 mKey; public: nsPRUint32Key(PRUint32 key) { mKeyType = PRUint32Key; mKey = key; } PRUint32 HashCode(void) const { return mKey; } PRBool Equals(const nsHashKey *aKey) const { return mKey == ((const nsPRUint32Key *) aKey)->mKey; } nsHashKey *Clone() const { return new nsPRUint32Key(mKey); } PRUint32 GetValue() { return mKey; } }; class nsVoidKey : public nsHashKey { protected: void* mKey; public: nsVoidKey(void* key) { mKeyType = VoidKey; mKey = key; } PRUint32 HashCode(void) const { return ((char *)(mKey) - (char *)0); } PRBool Equals(const nsHashKey *aKey) const { if (!(aKey->GetKeyType() == VoidKey)) nsDebug::Assertion("mismatched key types", "aKey->GetKeyType() == VoidKey", "../../dist/include/xpcom/nsHashtable.h", 282); return (mKey == ((const nsVoidKey *) aKey)->mKey); } nsHashKey *Clone() const { return new nsVoidKey(mKey); } void* GetValue() { return mKey; } }; class nsIDKey : public nsHashKey { protected: nsID mID; public: nsIDKey(const nsID &aID) { mKeyType = IDKey; mID = aID; } PRUint32 HashCode(void) const { return mID.m0; } PRBool Equals(const nsHashKey *aKey) const { if (!(aKey->GetKeyType() == IDKey)) nsDebug::Assertion("mismatched key types", "aKey->GetKeyType() == IDKey", "../../dist/include/xpcom/nsHashtable.h", 315); return (mID.Equals(((const nsIDKey *) aKey)->mID)); } nsHashKey *Clone() const { return new nsIDKey(mID); } nsIDKey(nsIObjectInputStream* aStream, nsresult *aResult); nsresult Write(nsIObjectOutputStream* aStream) const; }; class nsCStringKey : public nsHashKey { public: enum Ownership { NEVER_OWN, OWN_CLONE, OWN }; nsCStringKey(const char* str, PRInt32 strLen = -1, Ownership own = OWN_CLONE); nsCStringKey(const nsAFlatCString& str); nsCStringKey(const nsACString& str); ~nsCStringKey(void); PRUint32 HashCode(void) const; PRBool Equals(const nsHashKey* aKey) const; nsHashKey* Clone() const; nsCStringKey(nsIObjectInputStream* aStream, nsresult *aResult); nsresult Write(nsIObjectOutputStream* aStream) const; const char* GetString() const { return mStr; } PRUint32 GetStringLength() const { return mStrLen; } protected: char* mStr; PRUint32 mStrLen; Ownership mOwnership; }; class nsStringKey : public nsHashKey { public: enum Ownership { NEVER_OWN, OWN_CLONE, OWN }; nsStringKey(const PRUnichar* str, PRInt32 strLen = -1, Ownership own = OWN_CLONE); nsStringKey(const nsAFlatString& str); nsStringKey(const nsAString& str); ~nsStringKey(void); PRUint32 HashCode(void) const; PRBool Equals(const nsHashKey* aKey) const; nsHashKey* Clone() const; nsStringKey(nsIObjectInputStream* aStream, nsresult *aResult); nsresult Write(nsIObjectOutputStream* aStream) const; const PRUnichar* GetString() const { return mStr; } PRUint32 GetStringLength() const { return mStrLen; } protected: PRUnichar* mStr; PRUint32 mStrLen; Ownership mOwnership; }; class nsOpaqueKey : public nsHashKey { public: enum Ownership { NEVER_OWN, OWN_CLONE, OWN }; nsOpaqueKey(const char* buf, PRUint32 bufLen, Ownership own = OWN_CLONE); ~nsOpaqueKey(void); PRUint32 HashCode(void) const; PRBool Equals(const nsHashKey* aKey) const; nsHashKey* Clone() const; nsOpaqueKey(nsIObjectInputStream* aStream, nsresult *aResult); nsresult Write(nsIObjectOutputStream* aStream) const; const char* GetBuffer() const { return mBuf; } PRUint32 GetBufferLength() const { return mBufLen; } protected: char* mBuf; PRUint32 mBufLen; Ownership mOwnership; }; class nsIFileURL; class nsIFilePath; class nsIOutputStream; class nsIInputStream; class nsIFileSpec : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd8c0a080, 0x0868, 0x11d3, { 0x91, 0x5f, 0xd9, 0xd8, 0x89, 0xd4, 0x8e, 0x3c }}; return iid;} virtual nsresult FromFileSpec(const nsIFileSpec *original) = 0; virtual nsresult GetURLString(char * *aURLString) = 0; virtual nsresult SetURLString(const char * aURLString) = 0; virtual nsresult GetUnixStyleFilePath(char * *aUnixStyleFilePath) = 0; virtual nsresult SetUnixStyleFilePath(const char * aUnixStyleFilePath) = 0; virtual nsresult GetPersistentDescriptorString(char * *aPersistentDescriptorString) = 0; virtual nsresult SetPersistentDescriptorString(const char * aPersistentDescriptorString) = 0; virtual nsresult GetNativePath(char * *aNativePath) = 0; virtual nsresult SetNativePath(const char * aNativePath) = 0; virtual nsresult GetNSPRPath(char * *aNSPRPath) = 0; virtual nsresult Error(void) = 0; virtual nsresult IsValid(PRBool *_retval) = 0; virtual nsresult Failed(PRBool *_retval) = 0; virtual nsresult GetLeafName(char * *aLeafName) = 0; virtual nsresult SetLeafName(const char * aLeafName) = 0; virtual nsresult GetParent(nsIFileSpec * *aParent) = 0; virtual nsresult GetInputStream(nsIInputStream * *aInputStream) = 0; virtual nsresult GetOutputStream(nsIOutputStream * *aOutputStream) = 0; virtual nsresult IsChildOf(nsIFileSpec *possibleParent, PRBool *_retval) = 0; virtual nsresult GetFileSpec(nsFileSpec *aFileSpec) = 0; virtual nsresult SetFromFileSpec(const nsFileSpec & spec) = 0; virtual nsresult GetFileContents(char * *aFileContents) = 0; virtual nsresult SetFileContents(const char * aFileContents) = 0; virtual nsresult MakeUnique(void) = 0; virtual nsresult MakeUniqueWithSuggestedName(const char *suggestedName) = 0; virtual nsresult GetModDate(PRUint32 *aModDate) = 0; virtual nsresult ModDateChanged(PRUint32 oldStamp, PRBool *_retval) = 0; virtual nsresult IsDirectory(PRBool *_retval) = 0; virtual nsresult IsFile(PRBool *_retval) = 0; virtual nsresult Exists(PRBool *_retval) = 0; virtual nsresult IsHidden(PRBool *_retval) = 0; virtual nsresult Equals(nsIFileSpec *spec, PRBool *_retval) = 0; virtual nsresult GetFileSize(PRUint32 *aFileSize) = 0; virtual nsresult GetDiskSpaceAvailable(PRInt64 *aDiskSpaceAvailable) = 0; virtual nsresult AppendRelativeUnixPath(const char *relativePath) = 0; virtual nsresult CreateDir(void) = 0; virtual nsresult Touch(void) = 0; virtual nsresult IsSymlink(PRBool *_retval) = 0; virtual nsresult ResolveSymlink(void) = 0; virtual nsresult Delete(PRBool recursive) = 0; virtual nsresult Truncate(PRInt32 aNewLength) = 0; virtual nsresult Rename(const char *newLeafName) = 0; virtual nsresult CopyToDir(const nsIFileSpec *newParentDir) = 0; virtual nsresult MoveToDir(const nsIFileSpec *newParentDir) = 0; virtual nsresult Execute(const char *args) = 0; virtual nsresult OpenStreamForReading(void) = 0; virtual nsresult OpenStreamForWriting(void) = 0; virtual nsresult OpenStreamForReadingAndWriting(void) = 0; virtual nsresult CloseStream(void) = 0; virtual nsresult IsStreamOpen(PRBool *_retval) = 0; virtual nsresult Eof(PRBool *_retval) = 0; virtual nsresult Read(char **buffer, PRInt32 requestedCount, PRInt32 *_retval) = 0; virtual nsresult ReadLine(char **line, PRInt32 bufferSize, PRBool *wasTruncated) = 0; virtual nsresult Write(const char *data, PRInt32 requestedCount, PRInt32 *_retval) = 0; virtual nsresult Flush(void) = 0; virtual nsresult Seek(PRInt32 offset) = 0; virtual nsresult Tell(PRInt32 *_retval) = 0; virtual nsresult EndLine(void) = 0; }; class nsIDirectoryIterator : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd8c0a083, 0x0868, 0x11d3, { 0x91, 0x5f, 0xd9, 0xd8, 0x89, 0xd4, 0x8e, 0x3c }}; return iid;} virtual nsresult Init(nsIFileSpec *parent, PRBool resolveSymlink) = 0; virtual nsresult Exists(PRBool *_retval) = 0; virtual nsresult Next(void) = 0; virtual nsresult GetCurrentSpec(nsIFileSpec * *aCurrentSpec) = 0; }; nsresult NS_NewFileSpecWithSpec(const nsFileSpec& aSrcFileSpec, nsIFileSpec **result); nsresult NS_NewFileSpec(nsIFileSpec** result); nsresult NS_NewDirectoryIterator(nsIDirectoryIterator** result); inline PRBool Exists(nsIFileSpec* f) { PRBool yes; return (!((f->Exists(&yes)) & 0x80000000)) && yes; } inline PRBool Exists(nsIDirectoryIterator* f) { PRBool yes; return (!((f->Exists(&yes)) & 0x80000000)) && yes; } inline PRBool IsDirectory(nsIFileSpec* f) { PRBool yes; return (!((f->IsDirectory(&yes)) & 0x80000000)) && yes; } class nsIXPIListener : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xeea90d40, 0xb059, 0x11d2, { 0x91, 0x5e, 0xc1, 0x2b, 0x69, 0x6c, 0x93, 0x33 }}; return iid;} virtual nsresult BeforeJavascriptEvaluation(const PRUnichar *URL) = 0; virtual nsresult AfterJavascriptEvaluation(const PRUnichar *URL) = 0; virtual nsresult InstallStarted(const PRUnichar *URL, const PRUnichar *UIPackageName) = 0; virtual nsresult ItemScheduled(const PRUnichar *message) = 0; virtual nsresult FinalizeProgress(const PRUnichar *message, PRInt32 itemNum, PRInt32 totNum) = 0; virtual nsresult FinalStatus(const PRUnichar *URL, PRInt32 status) = 0; virtual nsresult LogComment(const PRUnichar *comment) = 0; }; inline PRBool DOMStringIsNull(const nsAReadableString& aString) { return aString.IsVoid(); } inline void SetDOMStringToNull(nsAWritableString& aString) { aString.Truncate(); aString.SetIsVoid(1); } typedef PRUint64 DOMTimeStamp; class nsIDOMAttr; class nsIDOMCDATASection; class nsIDOMCharacterData; class nsIDOMComment; class nsIDOMDOMImplementation; class nsIDOMDocument; class nsIDOMDocumentFragment; class nsIDOMDocumentType; class nsIDOMElement; class nsIDOMEntity; class nsIDOMEntityReference; class nsIDOMNSDocument; class nsIDOMNamedNodeMap; class nsIDOMNode; class nsIDOMNodeList; class nsIDOMNotation; class nsIDOMProcessingInstruction; class nsIDOMText; class DOMException; class nsIDOMStyleSheetList; class nsIDOMLinkStyle; class nsIDOMStyleSheet; class nsIDOMMediaList; class nsIDOMAbstractView; class nsIDOMDocumentView; class nsIDOMWindow; class nsIDOMWindowInternal; class nsIDOMWindowCollection; class nsIDOMPlugin; class nsIDOMPluginArray; class nsIDOMMimeType; class nsIDOMMimeTypeArray; class nsIDOMBarProp; class nsIDOMNavigator; class nsIDOMScreen; class nsIDOMHistory; class nsIDOMEvent; class nsIDOMEventTarget; class nsIDOMEventListener; class nsIDOMHTMLElement; class nsIDOMHTMLFormElement; class nsIDOMHTMLCollection; class nsIDOMCSSValue; class nsIDOMCSSPrimitiveValue; class nsIDOMCSSRule; class nsIDOMCSSRuleList; class nsIDOMCSSStyleSheet; class nsIDOMCSSStyleDeclaration; class nsIDOMCounter; class nsIDOMRect; class nsIDOMRGBColor; class nsIDOMCSSStyleRule; class nsIDOMCSSStyleRuleCollection; class nsIDOMHTMLTableCaptionElement; class nsIDOMHTMLTableSectionElement; class nsIDOMRange; class nsIDOMCRMFObject; class nsIDOMCrypto; class nsIDOMPkcs11; class nsISelection; class nsIDOMWindow : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xa6cf906b, 0x15b3, 0x11d2, { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }}; return iid;} virtual nsresult GetDocument(nsIDOMDocument * *aDocument) = 0; virtual nsresult GetParent(nsIDOMWindow * *aParent) = 0; virtual nsresult GetTop(nsIDOMWindow * *aTop) = 0; virtual nsresult GetScrollbars(nsIDOMBarProp * *aScrollbars) = 0; virtual nsresult GetFrames(nsIDOMWindowCollection * *aFrames) = 0; virtual nsresult GetName(nsAString & aName) = 0; virtual nsresult SetName(const nsAString & aName) = 0; virtual nsresult GetTextZoom(float *aTextZoom) = 0; virtual nsresult SetTextZoom(float aTextZoom) = 0; virtual nsresult GetScrollX(PRInt32 *aScrollX) = 0; virtual nsresult GetScrollY(PRInt32 *aScrollY) = 0; virtual nsresult ScrollTo(PRInt32 xScroll, PRInt32 yScroll) = 0; virtual nsresult ScrollBy(PRInt32 xScrollDif, PRInt32 yScrollDif) = 0; virtual nsresult GetSelection(nsISelection **_retval) = 0; virtual nsresult ScrollByLines(PRInt32 numLines) = 0; virtual nsresult ScrollByPages(PRInt32 numPages) = 0; virtual nsresult SizeToContent(void) = 0; }; class nsISidebar; class nsIPrompt; class nsIControllers; class nsIDOMLocation; class nsIPrintSettings; class nsIDOMWindowInternal : public nsIDOMWindow { public: static const nsIID& GetIID() {static const nsIID iid = {0x9c911860, 0x7dd9, 0x11d4, { 0x9a, 0x83, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}; return iid;} virtual nsresult GetWindow(nsIDOMWindowInternal * *aWindow) = 0; virtual nsresult GetSelf(nsIDOMWindowInternal * *aSelf) = 0; virtual nsresult GetNavigator(nsIDOMNavigator * *aNavigator) = 0; virtual nsresult GetScreen(nsIDOMScreen * *aScreen) = 0; virtual nsresult GetHistory(nsIDOMHistory * *aHistory) = 0; virtual nsresult GetContent(nsIDOMWindow * *aContent) = 0; virtual nsresult GetSidebar(nsISidebar * *aSidebar) = 0; virtual nsresult GetPrompter(nsIPrompt * *aPrompter) = 0; virtual nsresult GetMenubar(nsIDOMBarProp * *aMenubar) = 0; virtual nsresult GetToolbar(nsIDOMBarProp * *aToolbar) = 0; virtual nsresult GetLocationbar(nsIDOMBarProp * *aLocationbar) = 0; virtual nsresult GetPersonalbar(nsIDOMBarProp * *aPersonalbar) = 0; virtual nsresult GetStatusbar(nsIDOMBarProp * *aStatusbar) = 0; virtual nsresult GetDirectories(nsIDOMBarProp * *aDirectories) = 0; virtual nsresult GetClosed(PRBool *aClosed) = 0; virtual nsresult GetCrypto(nsIDOMCrypto * *aCrypto) = 0; virtual nsresult GetPkcs11(nsIDOMPkcs11 * *aPkcs11) = 0; virtual nsresult GetControllers(nsIControllers * *aControllers) = 0; virtual nsresult GetOpener(nsIDOMWindowInternal * *aOpener) = 0; virtual nsresult SetOpener(nsIDOMWindowInternal * aOpener) = 0; virtual nsresult GetStatus(nsAString & aStatus) = 0; virtual nsresult SetStatus(const nsAString & aStatus) = 0; virtual nsresult GetDefaultStatus(nsAString & aDefaultStatus) = 0; virtual nsresult SetDefaultStatus(const nsAString & aDefaultStatus) = 0; virtual nsresult GetLocation(nsIDOMLocation * *aLocation) = 0; virtual nsresult GetTitle(nsAString & aTitle) = 0; virtual nsresult SetTitle(const nsAString & aTitle) = 0; virtual nsresult GetInnerWidth(PRInt32 *aInnerWidth) = 0; virtual nsresult SetInnerWidth(PRInt32 aInnerWidth) = 0; virtual nsresult GetInnerHeight(PRInt32 *aInnerHeight) = 0; virtual nsresult SetInnerHeight(PRInt32 aInnerHeight) = 0; virtual nsresult GetOuterWidth(PRInt32 *aOuterWidth) = 0; virtual nsresult SetOuterWidth(PRInt32 aOuterWidth) = 0; virtual nsresult GetOuterHeight(PRInt32 *aOuterHeight) = 0; virtual nsresult SetOuterHeight(PRInt32 aOuterHeight) = 0; virtual nsresult GetScreenX(PRInt32 *aScreenX) = 0; virtual nsresult SetScreenX(PRInt32 aScreenX) = 0; virtual nsresult GetScreenY(PRInt32 *aScreenY) = 0; virtual nsresult SetScreenY(PRInt32 aScreenY) = 0; virtual nsresult GetPageXOffset(PRInt32 *aPageXOffset) = 0; virtual nsresult GetPageYOffset(PRInt32 *aPageYOffset) = 0; virtual nsresult GetLength(PRUint32 *aLength) = 0; virtual nsresult Alert(const nsAString & text) = 0; virtual nsresult Confirm(const nsAString & text, PRBool *_retval) = 0; virtual nsresult Prompt(const nsAString & aMessage, const nsAString & aInitial, const nsAString & aTitle, PRUint32 aSavePassword, nsAString & _retval) = 0; virtual nsresult Focus(void) = 0; virtual nsresult Blur(void) = 0; virtual nsresult Back(void) = 0; virtual nsresult Forward(void) = 0; virtual nsresult Home(void) = 0; virtual nsresult Stop(void) = 0; virtual nsresult Print(void) = 0; virtual nsresult PrintPreview(nsIPrintSettings *aPS) = 0; virtual nsresult PrintWithSettings(nsIPrintSettings *aPS) = 0; virtual nsresult MoveTo(PRInt32 xPos, PRInt32 yPos) = 0; virtual nsresult MoveBy(PRInt32 xDif, PRInt32 yDif) = 0; virtual nsresult ResizeTo(PRInt32 width, PRInt32 height) = 0; virtual nsresult ResizeBy(PRInt32 widthDif, PRInt32 heightDif) = 0; virtual nsresult GetAttention(void) = 0; virtual nsresult Scroll(PRInt32 xScroll, PRInt32 yScroll) = 0; virtual nsresult ClearTimeout(PRInt32 timerID) = 0; virtual nsresult ClearInterval(PRInt32 timerID) = 0; virtual nsresult SetCursor(const nsAString & cursor) = 0; virtual nsresult Open(const nsAString & url, const nsAString & name, const nsAString & options, nsIDOMWindow **_retval) = 0; virtual nsresult OpenDialog(const nsAString & url, const nsAString & name, const nsAString & options, nsISupports *aExtraArgument, nsIDOMWindow **_retval) = 0; virtual nsresult Close(void) = 0; virtual nsresult UpdateCommands(const nsAString & action) = 0; virtual nsresult Escape(const nsAString & str, nsAString & _retval) = 0; virtual nsresult Unescape(const nsAString & str, nsAString & _retval) = 0; virtual nsresult Find(const nsAString & str, PRBool caseSensitive, PRBool backwards, PRBool wrapAround, PRBool wholeWord, PRBool searchInFrames, PRBool showDialog, PRBool *_retval) = 0; }; class nsIEnumerator : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xad385286, 0xcbc4, 0x11d2, { 0x8c, 0xca, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} virtual nsresult First(void) = 0; virtual nsresult Next(void) = 0; virtual nsresult CurrentItem(nsISupports **_retval) = 0; virtual nsresult IsDone(void) = 0; }; class nsIBidirectionalEnumerator : public nsIEnumerator { public: static const nsIID& GetIID() {static const nsIID iid = {0x75f158a0, 0xcadd, 0x11d2, { 0x8c, 0xca, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} virtual nsresult Last(void) = 0; virtual nsresult Prev(void) = 0; }; extern "C" nsresult NS_NewEmptyEnumerator(nsISimpleEnumerator** aResult); extern "C" nsresult NS_NewConjoiningEnumerator(nsIEnumerator* first, nsIEnumerator* second, nsIBidirectionalEnumerator* *aInstancePtrResult); extern "C" nsresult NS_NewUnionEnumerator(nsIEnumerator* first, nsIEnumerator* second, nsIEnumerator* *aInstancePtrResult); extern "C" nsresult NS_NewIntersectionEnumerator(nsIEnumerator* first, nsIEnumerator* second, nsIEnumerator* *aInstancePtrResult); typedef PRUint32 nsRegistryKey; typedef PRInt32 nsWellKnownRegistry; class nsIRegistry : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x5d41a440, 0x8e37, 0x11d2, { 0x80, 0x59, 0x00, 0x60, 0x08, 0x11, 0xa9, 0xc3 }}; return iid;} enum { None = 0 }; enum { Users = 1 }; enum { Common = 2 }; enum { CurrentUser = 3 }; enum { ApplicationComponentRegistry = 1 }; enum { ApplicationRegistry = 2 }; enum { ApplicationCustomRegistry = -1 }; virtual nsresult Open(const char *regFile) = 0; virtual nsresult OpenWellKnownRegistry(nsWellKnownRegistry regid) = 0; virtual nsresult Flush(void) = 0; virtual nsresult IsOpen(PRBool *_retval) = 0; virtual nsresult AddKey(nsRegistryKey baseKey, const PRUnichar *keyname, nsRegistryKey *_retval) = 0; virtual nsresult GetKey(nsRegistryKey baseKey, const PRUnichar *keyname, nsRegistryKey *_retval) = 0; virtual nsresult RemoveKey(nsRegistryKey baseKey, const PRUnichar *keyname) = 0; virtual nsresult GetString(nsRegistryKey baseKey, const PRUnichar *valname, PRUnichar **_retval) = 0; virtual nsresult SetString(nsRegistryKey baseKey, const PRUnichar *valname, const PRUnichar *value) = 0; virtual nsresult GetStringUTF8(nsRegistryKey baseKey, const char *path, char **_retval) = 0; virtual nsresult SetStringUTF8(nsRegistryKey baseKey, const char *path, const char *value) = 0; virtual nsresult GetBytesUTF8(nsRegistryKey baseKey, const char *path, PRUint32 *length, PRUint8 **valueArray) = 0; virtual nsresult SetBytesUTF8(nsRegistryKey baseKey, const char *path, PRUint32 length, PRUint8 *valueArray) = 0; virtual nsresult GetInt(nsRegistryKey baseKey, const char *path, PRInt32 *_retval) = 0; virtual nsresult SetInt(nsRegistryKey baseKey, const char *path, PRInt32 value) = 0; virtual nsresult GetLongLong(nsRegistryKey baseKey, const char *path, PRInt64 *_retval) = 0; virtual nsresult SetLongLong(nsRegistryKey baseKey, const char *path, PRInt64 *value) = 0; virtual nsresult AddSubtree(nsRegistryKey baseKey, const char *path, nsRegistryKey *_retval) = 0; virtual nsresult RemoveSubtree(nsRegistryKey baseKey, const char *path) = 0; virtual nsresult GetSubtree(nsRegistryKey baseKey, const char *path, nsRegistryKey *_retval) = 0; virtual nsresult AddSubtreeRaw(nsRegistryKey baseKey, const char *path, nsRegistryKey *_retval) = 0; virtual nsresult RemoveSubtreeRaw(nsRegistryKey baseKey, const char *path) = 0; virtual nsresult GetSubtreeRaw(nsRegistryKey baseKey, const char *path, nsRegistryKey *_retval) = 0; virtual nsresult EnumerateSubtrees(nsRegistryKey baseKey, nsIEnumerator **_retval) = 0; virtual nsresult EnumerateAllSubtrees(nsRegistryKey baseKey, nsIEnumerator **_retval) = 0; virtual nsresult EnumerateValues(nsRegistryKey baseKey, nsIEnumerator **_retval) = 0; enum { String = 1U }; enum { Int32 = 2U }; enum { Bytes = 3U }; enum { File = 4U }; virtual nsresult GetValueType(nsRegistryKey baseKey, const char *path, PRUint32 *_retval) = 0; virtual nsresult GetValueLength(nsRegistryKey baseKey, const char *path, PRUint32 *_retval) = 0; virtual nsresult DeleteValue(nsRegistryKey baseKey, const char *path) = 0; virtual nsresult EscapeKey(PRUint8 *key, PRUint32 terminator, PRUint32 *length, PRUint8 **escaped) = 0; virtual nsresult UnescapeKey(PRUint8 *escaped, PRUint32 terminator, PRUint32 *length, PRUint8 **key) = 0; virtual nsresult GetCurrentUserName(char * *aCurrentUserName) = 0; virtual nsresult SetCurrentUserName(const char * aCurrentUserName) = 0; virtual nsresult Pack(void) = 0; }; class nsIRegistryEnumerator : public nsIEnumerator { public: static const nsIID& GetIID() {static const nsIID iid = {0x8cecf236, 0x1dd2, 0x11b2, { 0x89, 0x3c, 0xf9, 0x84, 0x89, 0x56, 0xea, 0xec }}; return iid;} virtual nsresult CurrentItemInPlaceUTF8(nsRegistryKey *key, const char **item) = 0; }; class nsIRegistryNode : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd1b54831, 0xac07, 0x11d2, { 0x80, 0x5e, 0x00, 0x60, 0x08, 0x11, 0xa9, 0xc3 }}; return iid;} virtual nsresult GetNameUTF8(char * *aNameUTF8) = 0; virtual nsresult GetName(PRUnichar * *aName) = 0; virtual nsresult GetKey(nsRegistryKey *aKey) = 0; }; class nsIRegistryValue : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x5316c380, 0xb2f8, 0x11d2, { 0xa3, 0x74, 0x00, 0x80, 0xc6, 0xf8, 0x0e, 0x4b }}; return iid;} virtual nsresult GetName(PRUnichar * *aName) = 0; virtual nsresult GetNameUTF8(char * *aNameUTF8) = 0; virtual nsresult GetType(PRUint32 *aType) = 0; virtual nsresult GetLength(PRUint32 *aLength) = 0; }; class nsIRegistryGetter : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x3a15fc88, 0x7a61, 0x4ab4, { 0x8e, 0x58, 0x31, 0xe9, 0x5f, 0xab, 0x3d, 0xa8 }}; return iid;} virtual nsresult GetStringUTF8IntoBuffer(nsRegistryKey baseKey, const char *path, char *buf, PRUint32 *length) = 0; virtual nsresult GetBytesUTF8IntoBuffer(nsRegistryKey baseKey, const char *path, PRUint8 *buf, PRUint32 *length) = 0; }; class nsISoftwareUpdate : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = { 0x18c2f992, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53}}; return iid;} virtual nsresult InstallJar(nsIFile* localFile, const PRUnichar* URL, const PRUnichar* arguments, nsIDOMWindowInternal* aParentWindow, PRUint32 flags, nsIXPIListener* aListener = 0) = 0; virtual nsresult InstallChrome(PRUint32 aType, nsIFile* aFile, const PRUnichar* URL, const PRUnichar* aName, PRBool aSelect, nsIXPIListener* aListener = 0) = 0; virtual nsresult RegisterListener(nsIXPIListener *aListener) = 0; virtual nsresult InstallJarCallBack() = 0; virtual nsresult GetMasterListener(nsIXPIListener **aListener) = 0; virtual nsresult SetActiveListener(nsIXPIListener *aListener) = 0; virtual nsresult StartupTasks( PRBool* outAutoreg ) = 0; }; class nsSoftwareUpdateModule : public nsIModule { public: nsSoftwareUpdateModule(); virtual ~nsSoftwareUpdateModule(); public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult GetClassObject(nsIComponentManager *aCompMgr, const nsCID & aClass, const nsIID & aIID, void * *result); virtual nsresult RegisterSelf(nsIComponentManager *aCompMgr, nsIFile *location, const char *registryLocation, const char *componentType); virtual nsresult UnregisterSelf(nsIComponentManager *aCompMgr, nsIFile *location, const char *registryLocation); virtual nsresult CanUnload(nsIComponentManager *aCompMgr, PRBool *_retval); protected: nsresult Initialize(); void Shutdown(); PRBool mInitialized; nsCOMPtr mSoftwareUpdateFactory; nsCOMPtr mInstallTriggerFactory; nsCOMPtr mInstallVersionFactory; }; inline PRBool NS_SoftwareUpdateNeedsAutoReg() { nsresult rv; PRBool needAutoReg = 1; nsCOMPtr reg = do_GetService("@mozilla.org/registry;1", &rv); if ((!((rv) & 0x80000000))) { rv = reg->OpenWellKnownRegistry(nsIRegistry::ApplicationComponentRegistry); if ((!((rv) & 0x80000000))) { nsRegistryKey idKey = 0; rv = reg->GetSubtree(nsIRegistry::Common, "software/mozilla/xpinstall", &idKey); if ((!((rv) & 0x80000000))) { char* autoRegVal = 0; rv = reg->GetStringUTF8(idKey, "Autoreg", &autoRegVal); if ((!((rv) & 0x80000000)) && (PL_strcmp(autoRegVal, "yes") != 0)) needAutoReg = 0; if (autoRegVal) nsMemory::Free(autoRegVal); } } } return needAutoReg; } inline void NS_SoftwareUpdateDidAutoReg() { nsresult rv; nsCOMPtr reg = do_GetService("@mozilla.org/registry;1", &rv); if ((!((rv) & 0x80000000))) { rv = reg->OpenWellKnownRegistry(nsIRegistry::ApplicationComponentRegistry); if ((!((rv) & 0x80000000))) { nsRegistryKey idKey = 0; rv = reg->AddSubtree(nsIRegistry::Common, "software/mozilla/xpinstall", &idKey); if ((!((rv) & 0x80000000))) reg->SetStringUTF8(idKey, "Autoreg", "no"); } } } inline void NS_SoftwareUpdateRequestAutoReg() { nsresult rv; nsCOMPtr reg = do_GetService("@mozilla.org/registry;1", &rv); if ((!((rv) & 0x80000000))) { rv = reg->OpenWellKnownRegistry(nsIRegistry::ApplicationComponentRegistry); if ((!((rv) & 0x80000000))) { nsRegistryKey idKey = 0; rv = reg->AddSubtree(nsIRegistry::Common, "software/mozilla/xpinstall", &idKey); if ((!((rv) & 0x80000000))) reg->SetStringUTF8(idKey, "Autoreg", "yes"); } } } class nsInstallInfo; class nsIScriptContext; class nsIScriptExternalNameSet : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xa6cf90da, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}; return iid;}; virtual nsresult InitializeNameSet(nsIScriptContext* aScriptContext) = 0; }; class nsIObserver : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xdb242e01, 0xe4d9, 0x11d2, { 0x9d, 0xde, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}; return iid;} virtual nsresult Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData) = 0; }; class nsPIXPIStubHook : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x089929f0, 0x4ed9, 0x11d3, { 0xab, 0xdd, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}; return iid;} virtual nsresult StubInitialize(nsIFile *dir, const char *logName) = 0; }; class nsTopProgressListener : public nsIXPIListener { public: nsTopProgressListener(); virtual ~nsTopProgressListener(); long RegisterListener(nsIXPIListener * newListener); void UnregisterListener(long id); void SetActiveListener(nsIXPIListener *aListener) { mActive = aListener; } public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult BeforeJavascriptEvaluation(const PRUnichar *URL); virtual nsresult AfterJavascriptEvaluation(const PRUnichar *URL); virtual nsresult InstallStarted(const PRUnichar *URL, const PRUnichar *UIPackageName); virtual nsresult ItemScheduled(const PRUnichar *message); virtual nsresult FinalizeProgress(const PRUnichar *message, PRInt32 itemNum, PRInt32 totNum); virtual nsresult FinalStatus(const PRUnichar *URL, PRInt32 status); virtual nsresult LogComment(const PRUnichar *comment); private: nsVoidArray *mListeners; PRLock *mLock; nsCOMPtr mActive; }; class nsSoftwareUpdate: public nsISoftwareUpdate, public nsPIXPIStubHook, public nsIObserver { public: static const nsID& GetCID() {static const nsID cid = { 0x18c2f989, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }; return cid;}; static nsSoftwareUpdate *GetInstance(); static nsIFile* GetProgramDirectory() { return mProgramDir; } static char* GetLogName() { return mLogName; } static void NeedCleanup() { mNeedCleanup = 1; } public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult StubInitialize(nsIFile *dir, const char *logName); virtual nsresult Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData); virtual nsresult InstallJar( nsIFile* localFile, const PRUnichar* URL, const PRUnichar* arguments, nsIDOMWindowInternal* aParentWindow, PRUint32 flags = 0, nsIXPIListener* aListener = 0); virtual nsresult InstallChrome( PRUint32 aType, nsIFile* aFile, const PRUnichar* URL, const PRUnichar* aName, PRBool aSelect, nsIXPIListener* aListener = 0); virtual nsresult RegisterListener(nsIXPIListener *aListener); virtual nsresult InstallJarCallBack(); virtual nsresult GetMasterListener(nsIXPIListener **aListener); virtual nsresult SetActiveListener(nsIXPIListener *aListener); virtual nsresult StartupTasks( PRBool* needAutoreg ); nsSoftwareUpdate(); virtual ~nsSoftwareUpdate(); static PRBool mNeedCleanup; private: static nsSoftwareUpdate* mInstance; static nsCOMPtr mProgramDir; static char* mLogName; nsresult RunNextInstall(); nsresult RegisterNameset(); void CreateMasterListener(); void Shutdown(); PRLock* mLock; PRBool mInstalling; nsVoidArray mJarInstallQueue; nsTopProgressListener *mMasterListener; HREG mReg; }; class nsSoftwareUpdateNameSet : public nsIScriptExternalNameSet { public: nsSoftwareUpdateNameSet(); virtual ~nsSoftwareUpdateNameSet(); public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult InitializeNameSet(nsIScriptContext* aScriptContext); }; class nsInstall; class nsInstallObject { public: nsInstallObject(nsInstall* inInstall) {mInstall = inInstall; } virtual ~nsInstallObject() {} virtual PRInt32 Prepare() = 0; virtual PRInt32 Complete() = 0; virtual char* toString() = 0; virtual void Abort() = 0; virtual PRBool CanUninstall() = 0; virtual PRBool RegisterPackageNode() = 0; protected: nsInstall* mInstall; }; class nsIScriptGlobalObject; class nsIScriptSecurityManager; class nsIScriptContextOwner; class nsIPrincipal; class nsIAtom; typedef void (*nsScriptTerminationFunc)(nsISupports* aRef); class nsIScriptContext : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = { 0x8f6bca7d, 0xce42, 0x11d1, {0xb7, 0x24, 0x00, 0x60, 0x08, 0x91, 0xd8, 0xc9} }; return iid;} virtual nsresult EvaluateString(const nsAReadableString& aScript, void *aScopeObject, nsIPrincipal *aPrincipal, const char *aURL, PRUint32 aLineNo, const char* aVersion, nsAWritableString& aRetValue, PRBool* aIsUndefined) = 0; virtual nsresult EvaluateStringWithValue(const nsAReadableString& aScript, void *aScopeObject, nsIPrincipal *aPrincipal, const char *aURL, PRUint32 aLineNo, const char* aVersion, void* aRetValue, PRBool* aIsUndefined) = 0; virtual nsresult CompileScript(const PRUnichar* aText, PRInt32 aTextLength, void* aScopeObject, nsIPrincipal* aPrincipal, const char* aURL, PRUint32 aLineNo, const char* aVersion, void** aScriptObject) = 0; virtual nsresult ExecuteScript(void* aScriptObject, void* aScopeObject, nsAWritableString* aRetValue, PRBool* aIsUndefined) = 0; virtual nsresult CompileEventHandler(void* aTarget, nsIAtom* aName, const nsAReadableString& aBody, PRBool aShared, void** aHandler) = 0; virtual nsresult CallEventHandler(void* aTarget, void* aHandler, PRUint32 argc, void* argv, PRBool* aBoolResult, PRBool aReverseReturnResult) = 0; virtual nsresult BindCompiledEventHandler(void* aTarget, nsIAtom* aName, void* aHandler) = 0; virtual nsresult CompileFunction(void* aTarget, const nsCString& aName, PRUint32 aArgCount, const char** aArgArray, const nsAReadableString& aBody, const char* aURL, PRUint32 aLineNo, PRBool aShared, void** aFunctionObject) = 0; virtual nsresult SetDefaultLanguageVersion(const char* aVersion) = 0; virtual nsresult GetGlobalObject(nsIScriptGlobalObject** aGlobalObject) = 0; virtual void* GetNativeContext() = 0; virtual nsresult InitContext(nsIScriptGlobalObject *aGlobalObject) = 0; virtual nsresult IsContextInitialized() = 0; virtual nsresult GC() = 0; virtual nsresult GetSecurityManager(nsIScriptSecurityManager** aInstancePtr) = 0; virtual nsresult ScriptEvaluated(PRBool aTerminated) = 0; virtual nsresult SetOwner(nsIScriptContextOwner* owner) = 0; virtual nsresult GetOwner(nsIScriptContextOwner** owner) = 0; virtual nsresult SetTerminationFunction(nsScriptTerminationFunc aFunc, nsISupports* aRef) = 0; virtual nsresult GetScriptsEnabled(PRBool *aEnabled) = 0; virtual nsresult SetScriptsEnabled(PRBool aEnabled) = 0; virtual nsresult GetProcessingScriptTag(PRBool * aResult) =0; virtual nsresult SetProcessingScriptTag(PRBool aResult) =0; virtual nsresult SetGCOnDestruction(PRBool aGCOnDestruction) = 0; }; class nsIScriptObjectOwner : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = { 0x8f6bca7e, 0xce42, 0x11d1, {0xb7, 0x24, 0x00, 0x60, 0x08, 0x91, 0xd8, 0xc9} }; return iid;} virtual nsresult GetScriptObject(nsIScriptContext *aContext, void** aScriptObject) = 0; virtual nsresult SetScriptObject(void* aScriptObject) = 0; }; class nsIAtom; class nsIScriptEventHandlerOwner : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = { 0x2ad54ae0, 0xa839, 0x11d3, {0xba, 0x97, 0x00, 0x10, 0x4b, 0xa0, 0x2d, 0x3d} }; return iid;} virtual nsresult CompileEventHandler(nsIScriptContext* aContext, void* aTarget, nsIAtom *aName, const nsAReadableString& aBody, void** aHandler) = 0; virtual nsresult GetCompiledEventHandler(nsIAtom *aName, void** aHandler) = 0; }; class nsIDOMInstallVersion; class nsIDOMInstallVersion : public nsISupports { public: static const nsIID& GetIID() { static nsIID iid = { 0x18c2f986, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53}}; return iid; } enum { EQUAL = 0, BLD_DIFF = 1, BLD_DIFF_MINUS = -1, REL_DIFF = 2, REL_DIFF_MINUS = -2, MINOR_DIFF = 3, MINOR_DIFF_MINUS = -3, MAJOR_DIFF = 4, MAJOR_DIFF_MINUS = -4 }; virtual nsresult GetMajor(PRInt32* aMajor)=0; virtual nsresult SetMajor(PRInt32 aMajor)=0; virtual nsresult GetMinor(PRInt32* aMinor)=0; virtual nsresult SetMinor(PRInt32 aMinor)=0; virtual nsresult GetRelease(PRInt32* aRelease)=0; virtual nsresult SetRelease(PRInt32 aRelease)=0; virtual nsresult GetBuild(PRInt32* aBuild)=0; virtual nsresult SetBuild(PRInt32 aBuild)=0; virtual nsresult Init(const nsString& aVersionString)=0; virtual nsresult ToString(nsString& aReturn)=0; virtual nsresult CompareTo(nsIDOMInstallVersion* aVersionObject, PRInt32* aReturn)=0; virtual nsresult CompareTo(const nsString& aString, PRInt32* aReturn)=0; virtual nsresult CompareTo(PRInt32 aMajor, PRInt32 aMinor, PRInt32 aRelease, PRInt32 aBuild, PRInt32* aReturn)=0; }; extern nsresult NS_InitInstallVersionClass(nsIScriptContext *aContext, void **aPrototype); extern "C" nsresult NS_NewScriptInstallVersion(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn); class nsInstallVersion: public nsIScriptObjectOwner, public nsIDOMInstallVersion { public: static const nsIID& IID() { static nsIID iid = { 0x18c2f98f, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }; return iid; } nsInstallVersion(); virtual ~nsInstallVersion(); public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult GetScriptObject(nsIScriptContext *aContext, void** aScriptObject); virtual nsresult SetScriptObject(void* aScriptObject); virtual nsresult Init(PRInt32 aMajor, PRInt32 aMinor, PRInt32 aRelease, PRInt32 aBuild); virtual nsresult Init(const nsString& aVersionString); virtual nsresult GetMajor(PRInt32* aMajor); virtual nsresult SetMajor(PRInt32 aMajor); virtual nsresult GetMinor(PRInt32* aMinor); virtual nsresult SetMinor(PRInt32 aMinor); virtual nsresult GetRelease(PRInt32* aRelease); virtual nsresult SetRelease(PRInt32 aRelease); virtual nsresult GetBuild(PRInt32* aBuild); virtual nsresult SetBuild(PRInt32 aBuild); virtual nsresult ToString(nsString& aReturn); virtual nsresult CompareTo(nsIDOMInstallVersion* aVersion, PRInt32* aReturn); virtual nsresult CompareTo(const nsString& aString, PRInt32* aReturn); virtual nsresult CompareTo(PRInt32 aMajor, PRInt32 aMinor, PRInt32 aRelease, PRInt32 aBuild, PRInt32* aReturn); static nsresult StringToVersionNumbers(const nsString& version, PRInt32 *aMajor, PRInt32 *aMinor, PRInt32 *aRelease, PRInt32 *aBuild); private: void *mScriptObject; PRInt32 major; PRInt32 minor; PRInt32 release; PRInt32 build; }; extern void StartupSpecialSystemDirectory(); extern void ShutdownSpecialSystemDirectory(); class nsSpecialSystemDirectory : public nsFileSpec { public: enum SystemDirectories { OS_DriveDirectory = 1 , OS_TemporaryDirectory = 2 , OS_CurrentProcessDirectory= 3 , OS_CurrentWorkingDirectory= 4 , XPCOM_CurrentProcessComponentDirectory= 5 , XPCOM_CurrentProcessComponentRegistry= 6 , Moz_BinDirectory = 10 , Mac_SystemDirectory = 101 , Mac_DesktopDirectory = 102 , Mac_TrashDirectory = 103 , Mac_StartupDirectory = 104 , Mac_ShutdownDirectory = 105 , Mac_AppleMenuDirectory = 106 , Mac_ControlPanelDirectory = 107 , Mac_ExtensionDirectory = 108 , Mac_FontsDirectory = 109 , Mac_ClassicPreferencesDirectory = 110 , Mac_DocumentsDirectory = 111 , Mac_InternetSearchDirectory = 112 , Mac_DefaultDownloadDirectory = 113 , Mac_UserLibDirectory = 114 , Mac_PreferencesDirectory = 115 , Win_SystemDirectory = 201 , Win_WindowsDirectory = 202 , Win_HomeDirectory = 203 , Win_Desktop = 204 , Win_Programs = 205 , Win_Controls = 206 , Win_Printers = 207 , Win_Personal = 208 , Win_Favorites = 209 , Win_Startup = 210 , Win_Recent = 211 , Win_Sendto = 212 , Win_Bitbucket = 213 , Win_Startmenu = 214 , Win_Desktopdirectory = 215 , Win_Drives = 216 , Win_Network = 217 , Win_Nethood = 218 , Win_Fonts = 219 , Win_Templates = 220 , Win_Common_Startmenu = 221 , Win_Common_Programs = 222 , Win_Common_Startup = 223 , Win_Common_Desktopdirectory = 224 , Win_Appdata = 225 , Win_Printhood = 226 , Unix_LocalDirectory = 301 , Unix_LibDirectory = 302 , Unix_HomeDirectory = 303 , BeOS_SettingsDirectory = 401 , BeOS_HomeDirectory = 402 , BeOS_DesktopDirectory = 403 , BeOS_SystemDirectory = 404 , OS2_SystemDirectory = 501 , OS2_OS2Directory = 502 , OS2_DesktopDirectory = 503 , OS2_HomeDirectory = 504 }; nsSpecialSystemDirectory(SystemDirectories aSystemSystemDirectory); virtual ~nsSpecialSystemDirectory(); void operator = (SystemDirectories aSystemSystemDirectory); static void Set(SystemDirectories dirToSet, nsFileSpec *dirSpec); private: void operator = (const char* inPath) { *(nsFileSpec*)this = inPath; } }; class nsInstallFolder { public: nsInstallFolder(); virtual ~nsInstallFolder(); nsresult Init(nsInstallFolder& inFolder, const nsString& subString); nsresult Init(const nsString& aFolderID, const nsString& aRelativePath); nsresult Init(nsIFile* rawIFile); void GetDirectoryPath(nsCString& aDirectoryPath); nsIFile* GetFileSpec(); PRInt32 ToString(nsAutoString* outString); private: nsCOMPtr mFileSpec; void SetDirectoryPath(const nsString& aFolderID, const nsString& aRelativePath); void AppendXPPath(const nsString& aRelativePath); PRInt32 MapNameToEnum(const nsString& name); }; class nsPIXPIProxy : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x6f9d2890, 0x167d, 0x11d5, { 0x8d, 0xaf, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}; return iid;} virtual nsresult RefreshPlugins(nsISupports *aWindow) = 0; virtual nsresult NotifyRestartNeeded(void) = 0; }; class nsIStringBundle : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd85a17c2, 0xaa7c, 0x11d2, { 0x9b, 0x8c, 0x00, 0x80, 0x5f, 0x8a, 0x16, 0xd9 }}; return iid;} virtual nsresult GetStringFromID(PRInt32 aID, PRUnichar **_retval) = 0; virtual nsresult GetStringFromName(const PRUnichar *aName, PRUnichar **_retval) = 0; virtual nsresult FormatStringFromID(PRInt32 aID, const PRUnichar **params, PRUint32 length, PRUnichar **_retval) = 0; virtual nsresult FormatStringFromName(const PRUnichar *aName, const PRUnichar **params, PRUint32 length, PRUnichar **_retval) = 0; virtual nsresult GetSimpleEnumeration(nsISimpleEnumerator **_retval) = 0; }; class nsIStringBundleService : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd85a17c0, 0xaa7c, 0x11d2, { 0x9b, 0x8c, 0x00, 0x80, 0x5f, 0x8a, 0x16, 0xd9 }}; return iid;} virtual nsresult CreateBundle(const char *aURLSpec, nsIStringBundle **_retval) = 0; virtual nsresult CreateAsyncBundle(const char *aURLSpec, nsIStringBundle **_retval) = 0; virtual nsresult CreateExtensibleBundle(const char *aRegistryKey, nsIStringBundle **_retval) = 0; virtual nsresult FormatStatusMessage(nsresult aStatus, const PRUnichar *aStatusArg, PRUnichar **_retval) = 0; virtual nsresult FlushBundles(void) = 0; }; class nsILocale : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x21035ee0, 0x4556, 0x11d3, { 0x91, 0xcd, 0x00, 0x10, 0x5a, 0xa3, 0xf7, 0xdc }}; return iid;} virtual nsresult GetCategory(const PRUnichar *category, PRUnichar **_retval) = 0; }; class nsIEventQueue : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x176afb41, 0x00a4, 0x11d3, { 0x9f, 0x2a, 0x00, 0x40, 0x05, 0x53, 0xee, 0xf0 }}; return iid;} virtual nsresult InitEvent(PLEvent * aEvent, void * owner, PLHandleEventProc handler, PLDestroyEventProc destructor) = 0; virtual PRStatus PostEvent(PLEvent * aEvent) = 0; virtual nsresult PostSynchronousEvent(PLEvent * aEvent, void * *aResult) = 0; virtual nsresult PendingEvents(PRBool *_retval) = 0; virtual nsresult ProcessPendingEvents(void) = 0; virtual nsresult EventLoop(void) = 0; virtual nsresult EventAvailable(PRBool & aResult) = 0; virtual nsresult GetEvent(PLEvent * *_retval) = 0; virtual nsresult HandleEvent(PLEvent * aEvent) = 0; virtual nsresult WaitForEvent(PLEvent * *_retval) = 0; virtual PRInt32 GetEventQueueSelectFD(void) = 0; virtual nsresult Init(PRBool aNative) = 0; virtual nsresult InitFromPRThread(PRThread * thread, PRBool aNative) = 0; virtual nsresult InitFromPLQueue(PLEventQueue * aQueue) = 0; virtual nsresult EnterMonitor(void) = 0; virtual nsresult ExitMonitor(void) = 0; virtual nsresult RevokeEvents(void * owner) = 0; virtual nsresult GetPLEventQueue(PLEventQueue * *_retval) = 0; virtual nsresult IsQueueOnCurrentThread(PRBool *_retval) = 0; virtual nsresult IsQueueNative(PRBool *_retval) = 0; virtual nsresult StopAcceptingEvents(void) = 0; }; class nsIThread; class nsIEventQueueService : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xa6cf90dc, 0x15b3, 0x11d2, { 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }}; return iid;} virtual nsresult CreateThreadEventQueue(void) = 0; virtual nsresult CreateMonitoredThreadEventQueue(void) = 0; virtual nsresult DestroyThreadEventQueue(void) = 0; virtual nsresult CreateFromIThread(nsIThread *aThread, PRBool aNative, nsIEventQueue **_retval) = 0; virtual nsresult CreateFromPLEventQueue(PLEventQueue * aPLEventQueue, nsIEventQueue **_retval) = 0; virtual nsresult PushThreadEventQueue(nsIEventQueue **_retval) = 0; virtual nsresult PopThreadEventQueue(nsIEventQueue *aQueue) = 0; virtual nsresult GetThreadEventQueue(PRThread * aThread, nsIEventQueue **_retval) = 0; virtual nsresult ResolveEventQueue(nsIEventQueue *queueOrConstant, nsIEventQueue **_retval) = 0; virtual nsresult GetSpecialEventQueue(PRInt32 aQueue, nsIEventQueue **_retval) = 0; enum { CURRENT_THREAD_EVENT_QUEUE = 0 }; enum { UI_THREAD_EVENT_QUEUE = 1 }; }; class nsIObjectInputStream; class nsIObjectOutputStream; class nsISerializable : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x91cca981, 0xc26d, 0x44a8, { 0xbe, 0xbe, 0xd9, 0xed, 0x48, 0x91, 0x50, 0x3a }}; return iid;} virtual nsresult Read(nsIObjectInputStream *aInputStream) = 0; virtual nsresult Write(nsIObjectOutputStream *aOutputStream) = 0; }; class nsICollection : public nsISerializable { public: static const nsIID& GetIID() {static const nsIID iid = {0x83b6019c, 0xcbc4, 0x11d2, { 0x8c, 0xca, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} virtual nsresult Count(PRUint32 *_retval) = 0; virtual nsresult GetElementAt(PRUint32 index, nsISupports **_retval) = 0; virtual nsresult QueryElementAt(PRUint32 index, const nsIID & uuid, void * *result) = 0; virtual nsresult SetElementAt(PRUint32 index, nsISupports *item) = 0; virtual nsresult AppendElement(nsISupports *item) = 0; virtual nsresult RemoveElement(nsISupports *item) = 0; virtual nsresult Enumerate(nsIEnumerator **_retval) = 0; virtual nsresult Clear(void) = 0; }; class nsQueryElementAt : public nsCOMPtr_helper { public: nsQueryElementAt( nsICollection* aCollection, PRUint32 aIndex, nsresult* aErrorPtr ) : mCollection(aCollection), mIndex(aIndex), mErrorPtr(aErrorPtr) { } virtual nsresult operator()( const nsIID& aIID, void** ) const; private: nsICollection* mCollection; PRUint32 mIndex; nsresult* mErrorPtr; }; inline const nsQueryElementAt do_QueryElementAt( nsICollection* aCollection, PRUint32 aIndex, nsresult* aErrorPtr = 0 ) { return nsQueryElementAt(aCollection, aIndex, aErrorPtr); } class nsIBidirectionalEnumerator; typedef PRBool (*nsISupportsArrayEnumFunc)(nsISupports* aElement, void *aData); class nsISupportsArray : public nsICollection { public: static const nsIID& GetIID() {static const nsIID iid = {0x791eafa0, 0xb9e6, 0x11d1, { 0x80, 0x31, 0x00, 0x60, 0x08, 0x15, 0x9b, 0x5a }}; return iid;} virtual PRBool Equals(const nsISupportsArray *other) = 0; virtual nsISupports * ElementAt(PRUint32 aIndex) = 0; virtual PRInt32 IndexOf(const nsISupports *aPossibleElement) = 0; virtual PRInt32 IndexOfStartingAt(const nsISupports *aPossibleElement, PRUint32 aStartIndex) = 0; virtual PRInt32 LastIndexOf(const nsISupports *aPossibleElement) = 0; virtual nsresult GetIndexOf(nsISupports *aPossibleElement, PRInt32 *_retval) = 0; virtual nsresult GetIndexOfStartingAt(nsISupports *aPossibleElement, PRUint32 aStartIndex, PRInt32 *_retval) = 0; virtual nsresult GetLastIndexOf(nsISupports *aPossibleElement, PRInt32 *_retval) = 0; virtual PRBool InsertElementAt(nsISupports *aElement, PRUint32 aIndex) = 0; virtual PRBool ReplaceElementAt(nsISupports *aElement, PRUint32 aIndex) = 0; virtual PRBool RemoveElementAt(PRUint32 aIndex) = 0; virtual PRBool RemoveLastElement(const nsISupports *aElement) = 0; virtual nsresult DeleteLastElement(nsISupports *aElement) = 0; virtual nsresult DeleteElementAt(PRUint32 aIndex) = 0; virtual PRBool AppendElements(nsISupportsArray *aElements) = 0; virtual nsresult Compact(void) = 0; virtual PRBool EnumerateForwards(nsISupportsArrayEnumFunc aFunc, void * aData) = 0; virtual PRBool EnumerateBackwards(nsISupportsArrayEnumFunc aFunc, void * aData) = 0; virtual nsresult Clone(nsISupportsArray **_retval) = 0; virtual PRBool MoveElement(PRInt32 aFrom, PRInt32 aTo) = 0; virtual PRBool InsertElementsAt(nsISupportsArray *aOther, PRUint32 aIndex) = 0; virtual PRBool RemoveElementsAt(PRUint32 aIndex, PRUint32 aCount) = 0; virtual PRBool SizeTo(PRInt32 aSize) = 0; private: virtual PRBool operator==(const nsISupportsArray& other) = 0; virtual nsISupports* operator[](PRUint32 aIndex) = 0; }; extern nsresult NS_NewISupportsArray(nsISupportsArray** aInstancePtrResult); extern nsresult NS_NewISupportsArrayEnumerator(nsISupportsArray* array, nsIBidirectionalEnumerator* *aInstancePtrResult); class nsIInputStream; class nsIInputStreamObserver; typedef nsresult (* nsWriteSegmentFun)(nsIInputStream* in, void* closure, const char* fromRawSegment, PRUint32 toOffset, PRUint32 count, PRUint32 *writeCount); class nsIInputStream : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xfa9c7f6c, 0x61b3, 0x11d4, { 0x98, 0x77, 0x00, 0xc0, 0x4f, 0xa0, 0xcf, 0x4a }}; return iid;} virtual nsresult Close(void) = 0; virtual nsresult Available(PRUint32 *_retval) = 0; virtual nsresult Read(char * buf, PRUint32 count, PRUint32 *_retval) = 0; virtual nsresult ReadSegments(nsWriteSegmentFun writer, void * closure, PRUint32 count, PRUint32 *_retval) = 0; virtual nsresult GetNonBlocking(PRBool *aNonBlocking) = 0; virtual nsresult GetObserver(nsIInputStreamObserver * *aObserver) = 0; virtual nsresult SetObserver(nsIInputStreamObserver * aObserver) = 0; }; class nsIInputStreamObserver : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x019d67cc, 0x61b4, 0x11d4, { 0x98, 0x77, 0x00, 0xc0, 0x4f, 0xa0, 0xcf, 0x4a }}; return iid;} virtual nsresult OnEmpty(nsIInputStream *inStr) = 0; virtual nsresult OnClose(nsIInputStream *inStr) = 0; }; class nsIOutputStream; class nsIOutputStreamObserver; class nsIInputStream; typedef nsresult (* nsReadSegmentFun)(nsIOutputStream* out, void* closure, char* toRawSegment, PRUint32 fromOffset, PRUint32 count, PRUint32 *readCount); class nsIOutputStream : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x0d0acd2a, 0x61b4, 0x11d4, { 0x98, 0x77, 0x00, 0xc0, 0x4f, 0xa0, 0xcf, 0x4a }}; return iid;} virtual nsresult Close(void) = 0; virtual nsresult Flush(void) = 0; virtual nsresult Write(const char *buf, PRUint32 count, PRUint32 *_retval) = 0; virtual nsresult WriteFrom(nsIInputStream *inStr, PRUint32 count, PRUint32 *_retval) = 0; virtual nsresult WriteSegments(nsReadSegmentFun reader, void * closure, PRUint32 count, PRUint32 *_retval) = 0; virtual nsresult GetNonBlocking(PRBool *aNonBlocking) = 0; virtual nsresult SetNonBlocking(PRBool aNonBlocking) = 0; virtual nsresult GetObserver(nsIOutputStreamObserver * *aObserver) = 0; virtual nsresult SetObserver(nsIOutputStreamObserver * aObserver) = 0; }; class nsIOutputStreamObserver : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x12314194, 0x61b4, 0x11d4, { 0x98, 0x77, 0x00, 0xc0, 0x4f, 0xa0, 0xcf, 0x4a }}; return iid;} virtual nsresult OnWrite(nsIOutputStream *outStr, PRUint32 amount) = 0; virtual nsresult OnFull(nsIOutputStream *outStr) = 0; }; class nsIPropertyElement : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x283ee646, 0x1aef, 0x11d4, { 0x98, 0xb3, 0x00, 0xc0, 0x4f, 0xa0, 0xce, 0x9a }}; return iid;} virtual nsresult GetKey(PRUnichar * *aKey) = 0; virtual nsresult SetKey(const PRUnichar * aKey) = 0; virtual nsresult GetValue(PRUnichar * *aValue) = 0; virtual nsresult SetValue(const PRUnichar * aValue) = 0; }; static const nsCID kPropertyElementCID = { 0x283ee645, 0x1aef, 0x11d4, { 0x98, 0xb3, 0x0, 0xc0, 0x4f, 0xa0, 0xce, 0x9a } }; static const nsCID kPersistentPropertiesCID = { 0x2245e573, 0x9464, 0x11d2, { 0x9b, 0x8b, 0x0, 0x80, 0x5f, 0x8a, 0x16, 0xd9 } }; class nsIPersistentProperties : public nsIProperties { public: static const nsIID& GetIID() { static nsIID iid = { 0x1a180f60, 0x93b2, 0x11d2, { 0x9b, 0x8b, 0x0, 0x80, 0x5f, 0x8a, 0x16, 0xd9 } }; return iid; } virtual nsresult Load(nsIInputStream* aIn) = 0; virtual nsresult Save(nsIOutputStream* aOut, const nsString& aHeader) = 0; virtual nsresult Subclass(nsIPersistentProperties* aSubclass) = 0; virtual nsresult EnumerateProperties(nsIBidirectionalEnumerator** aResult) = 0; virtual nsresult SimpleEnumerateProperties(nsISimpleEnumerator** aResult) = 0; virtual nsresult GetStringProperty(const nsAString& aKey, nsAString& aValue) = 0; virtual nsresult SetStringProperty(const nsAString& aKey, nsAString& aNewValue, nsAString& aOldValue) = 0; }; class nsISimpleEnumerator; class nsIInputStream; class nsIFile; class nsIZipEntry : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x6ca5e43e, 0x9632, 0x11d3, { 0x8c, 0xd9, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} virtual nsresult GetName(char * *aName) = 0; virtual nsresult GetCompression(PRUint16 *aCompression) = 0; virtual nsresult GetSize(PRUint32 *aSize) = 0; virtual nsresult GetRealSize(PRUint32 *aRealSize) = 0; virtual nsresult GetCRC32(PRUint32 *aCRC32) = 0; }; class nsIZipReader : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x6ff6a966, 0x9632, 0x11d3, { 0x8c, 0xd9, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} virtual nsresult Init(nsIFile *zipFile) = 0; virtual nsresult GetFile(nsIFile * *aFile) = 0; virtual nsresult Open(void) = 0; virtual nsresult Close(void) = 0; virtual nsresult Test(const char *aEntryName) = 0; virtual nsresult Extract(const char *zipEntry, nsIFile *outFile) = 0; virtual nsresult GetEntry(const char *zipEntry, nsIZipEntry **_retval) = 0; virtual nsresult FindEntries(const char *aPattern, nsISimpleEnumerator **_retval) = 0; virtual nsresult GetInputStream(const char *zipEntry, nsIInputStream **_retval) = 0; }; class nsIZipReaderCache : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x52c45d86, 0x0cc3, 0x11d4, { 0x98, 0x6e, 0x00, 0xc0, 0x4f, 0xa0, 0xcf, 0x4a }}; return iid;} virtual nsresult Init(PRUint32 cacheSize) = 0; virtual nsresult GetZip(nsIFile *zipFile, nsIZipReader **_retval) = 0; }; class nsIURI : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x07a22cc0, 0x0ce5, 0x11d3, { 0x93, 0x31, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}; return iid;} virtual nsresult GetSpec(char * *aSpec) = 0; virtual nsresult SetSpec(const char * aSpec) = 0; virtual nsresult GetPrePath(char * *aPrePath) = 0; virtual nsresult SetPrePath(const char * aPrePath) = 0; virtual nsresult GetScheme(char * *aScheme) = 0; virtual nsresult SetScheme(const char * aScheme) = 0; virtual nsresult GetPreHost(char * *aPreHost) = 0; virtual nsresult SetPreHost(const char * aPreHost) = 0; virtual nsresult GetUsername(char * *aUsername) = 0; virtual nsresult SetUsername(const char * aUsername) = 0; virtual nsresult GetPassword(char * *aPassword) = 0; virtual nsresult SetPassword(const char * aPassword) = 0; virtual nsresult GetHost(char * *aHost) = 0; virtual nsresult SetHost(const char * aHost) = 0; virtual nsresult GetPort(PRInt32 *aPort) = 0; virtual nsresult SetPort(PRInt32 aPort) = 0; virtual nsresult GetPath(char * *aPath) = 0; virtual nsresult SetPath(const char * aPath) = 0; virtual nsresult Equals(nsIURI *other, PRBool *_retval) = 0; virtual nsresult SchemeIs(const char *scheme, PRBool *_retval) = 0; virtual nsresult Clone(nsIURI **_retval) = 0; virtual nsresult Resolve(const char *relativePath, char **_retval) = 0; }; class nsIURL : public nsIURI { public: static const nsIID& GetIID() {static const nsIID iid = {0xd6116970, 0x8034, 0x11d3, { 0x93, 0x99, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}; return iid;} virtual nsresult GetFilePath(char * *aFilePath) = 0; virtual nsresult SetFilePath(const char * aFilePath) = 0; virtual nsresult GetParam(char * *aParam) = 0; virtual nsresult SetParam(const char * aParam) = 0; virtual nsresult GetQuery(char * *aQuery) = 0; virtual nsresult SetQuery(const char * aQuery) = 0; virtual nsresult GetRef(char * *aRef) = 0; virtual nsresult SetRef(const char * aRef) = 0; virtual nsresult GetDirectory(char * *aDirectory) = 0; virtual nsresult SetDirectory(const char * aDirectory) = 0; virtual nsresult GetFileName(char * *aFileName) = 0; virtual nsresult SetFileName(const char * aFileName) = 0; virtual nsresult GetFileBaseName(char * *aFileBaseName) = 0; virtual nsresult SetFileBaseName(const char * aFileBaseName) = 0; virtual nsresult GetFileExtension(char * *aFileExtension) = 0; virtual nsresult SetFileExtension(const char * aFileExtension) = 0; virtual nsresult GetEscapedQuery(char * *aEscapedQuery) = 0; }; class nsIStandardURL : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x8793370a, 0x311f, 0x11d4, { 0x98, 0x76, 0x00, 0xc0, 0x4f, 0xa0, 0xcf, 0x4a }}; return iid;} enum { URLTYPE_STANDARD = 1U }; enum { URLTYPE_AUTHORITY = 2U }; enum { URLTYPE_NO_AUTHORITY = 3U }; virtual nsresult Init(PRUint32 urlType, PRInt32 defaultPort, const char *initialSpec, nsIURI *initialBaseURI) = 0; }; class nsIDocShell; class nsIChromeRegistry : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xd8c7d8a1, 0xe84c, 0x11d2, { 0xbf, 0x87, 0x00, 0x10, 0x5a, 0x1b, 0x06, 0x27 }}; return iid;} enum { NONE = 0 }; enum { PARTIAL = 1 }; enum { FULL = 2 }; virtual nsresult Canonify(nsIURI *aChromeURL) = 0; virtual nsresult ConvertChromeURL(nsIURI *aChromeURL, char **_retval) = 0; virtual nsresult GetOverlays(nsIURI *aChromeURL, nsISimpleEnumerator **_retval) = 0; virtual nsresult GetStyleSheets(nsIURI *aChromeURL, nsISupportsArray **_retval) = 0; virtual nsresult ReloadChrome(void) = 0; virtual nsresult RefreshSkins(void) = 0; virtual nsresult SelectSkin(const PRUnichar *skinName, PRBool useProfile) = 0; virtual nsresult SelectLocale(const PRUnichar *localeName, PRBool useProfile) = 0; virtual nsresult DeselectSkin(const PRUnichar *skinName, PRBool useProfile) = 0; virtual nsresult DeselectLocale(const PRUnichar *localeName, PRBool useProfile) = 0; virtual nsresult IsSkinSelected(const PRUnichar *skinName, PRBool useProfile, PRInt32 *_retval) = 0; virtual nsresult IsLocaleSelected(const PRUnichar *localeName, PRBool useProfile, PRInt32 *_retval) = 0; virtual nsresult SelectSkinForPackage(const PRUnichar *skinName, const PRUnichar *packageName, PRBool useProfile) = 0; virtual nsresult SelectLocaleForPackage(const PRUnichar *localeName, const PRUnichar *packageName, PRBool useProfile) = 0; virtual nsresult DeselectSkinForPackage(const PRUnichar *skinName, const PRUnichar *packageName, PRBool useProfile) = 0; virtual nsresult DeselectLocaleForPackage(const PRUnichar *localeName, const PRUnichar *packageName, PRBool useProfile) = 0; virtual nsresult IsSkinSelectedForPackage(const PRUnichar *skinName, const PRUnichar *packageName, PRBool useProfile, PRBool *_retval) = 0; virtual nsresult IsLocaleSelectedForPackage(const PRUnichar *localeName, const PRUnichar *packageName, PRBool useProfile, PRBool *_retval) = 0; virtual nsresult SelectLocaleForProfile(const PRUnichar *localeName, const PRUnichar *profilePath) = 0; virtual nsresult GetSelectedLocale(const PRUnichar *packageName, PRUnichar **_retval) = 0; virtual nsresult InstallSkin(const char *baseURL, PRBool useProfile, PRBool allowScripts) = 0; virtual nsresult UninstallSkin(const PRUnichar *skinName, PRBool useProfile) = 0; virtual nsresult InstallLocale(const char *baseURL, PRBool useProfile) = 0; virtual nsresult UninstallLocale(const PRUnichar *localeName, PRBool useProfile) = 0; virtual nsresult InstallPackage(const char *baseURL, PRBool useProfile) = 0; virtual nsresult UninstallPackage(const PRUnichar *packageName, PRBool useProfile) = 0; virtual nsresult GetAgentSheets(nsIDocShell *docShell, nsISupportsArray **styleSheets) = 0; virtual nsresult GetUserSheets(PRBool useChromeSheets, nsISupportsArray **styleSheets) = 0; virtual nsresult AllowScriptsForSkin(nsIURI *url, PRBool *_retval) = 0; virtual nsresult CheckForNewChrome(void) = 0; virtual nsresult CheckThemeVersion(const PRUnichar *skinName, PRBool *_retval) = 0; virtual nsresult CheckLocaleVersion(const PRUnichar *localeName, PRBool *_retval) = 0; }; class nsInstallInfo { public: nsInstallInfo( PRUint32 aInstallType, nsIFile* aFile, const PRUnichar* aURL, const PRUnichar* aArgs, PRUint32 aFlags, nsIXPIListener* aListener, nsIDOMWindowInternal* aParentWindow, nsIChromeRegistry* aChromeReg); virtual ~nsInstallInfo(); nsIFile* GetFile() { return mFile.get(); } const PRUnichar* GetURL() { return mURL.get(); } const PRUnichar* GetArguments() { return mArgs.get(); } PRUint32 GetFlags() { return mFlags; } PRUint32 GetType() { return mType; } nsIXPIListener* GetListener() { return mListener.get(); } nsIChromeRegistry* GetChromeRegistry() { return mChromeReg.get(); } nsIDOMWindowInternal* GetParentDOMWindow() { return mParent.get(); } private: nsresult mError; PRUint32 mType; PRUint32 mFlags; nsString mURL; nsString mArgs; nsCOMPtr mFile; nsCOMPtr mListener; nsCOMPtr mParent; nsCOMPtr mChromeReg; }; class nsInstall { friend class nsWinReg; friend class nsWinProfile; public: enum { BAD_PACKAGE_NAME = -200, UNEXPECTED_ERROR = -201, ACCESS_DENIED = -202, TOO_MANY_CERTIFICATES = -203, NO_INSTALL_SCRIPT = -204, NO_CERTIFICATE = -205, NO_MATCHING_CERTIFICATE = -206, CANT_READ_ARCHIVE = -207, INVALID_ARGUMENTS = -208, ILLEGAL_RELATIVE_PATH = -209, USER_CANCELLED = -210, INSTALL_NOT_STARTED = -211, SILENT_MODE_DENIED = -212, NO_SUCH_COMPONENT = -213, DOES_NOT_EXIST = -214, READ_ONLY = -215, IS_DIRECTORY = -216, NETWORK_FILE_IS_IN_USE = -217, APPLE_SINGLE_ERR = -218, INVALID_PATH_ERR = -219, PATCH_BAD_DIFF = -220, PATCH_BAD_CHECKSUM_TARGET = -221, PATCH_BAD_CHECKSUM_RESULT = -222, UNINSTALL_FAILED = -223, PACKAGE_FOLDER_NOT_SET = -224, EXTRACTION_FAILED = -225, FILENAME_ALREADY_USED = -226, INSTALL_CANCELLED = -227, DOWNLOAD_ERROR = -228, SCRIPT_ERROR = -229, ALREADY_EXISTS = -230, IS_FILE = -231, SOURCE_DOES_NOT_EXIST = -232, SOURCE_IS_DIRECTORY = -233, SOURCE_IS_FILE = -234, INSUFFICIENT_DISK_SPACE = -235, FILENAME_TOO_LONG = -236, UNABLE_TO_LOCATE_LIB_FUNCTION = -237, UNABLE_TO_LOAD_LIBRARY = -238, CHROME_REGISTRY_ERROR = -239, MALFORMED_INSTALL = -240, KEY_ACCESS_DENIED = -241, KEY_DOES_NOT_EXIST = -242, VALUE_DOES_NOT_EXIST = -243, OUT_OF_MEMORY = -299, GESTALT_UNKNOWN_ERR = -5550, GESTALT_INVALID_ARGUMENT = -5551, SUCCESS = 0, REBOOT_NEEDED = 999, INSTALL_FILE_UNEXPECTED_MSG_ID = 0, DETAILS_REPLACE_FILE_MSG_ID = 1, DETAILS_INSTALL_FILE_MSG_ID = 2, DO_NOT_UNINSTALL = 2, WIN_SHARED_FILE = 4 }; nsInstall(nsIZipReader * theJARFile); virtual ~nsInstall(); PRInt32 SetScriptObject(void* aScriptObject); PRInt32 SaveWinRegPrototype(void* aScriptObject); PRInt32 SaveWinProfilePrototype(void* aScriptObject); JSObject* RetrieveWinRegPrototype(void); JSObject* RetrieveWinProfilePrototype(void); PRInt32 AbortInstall(PRInt32 aErrorNumber); PRInt32 AddDirectory(const nsString& aRegName, const nsString& aVersion, const nsString& aJarSource, nsInstallFolder* aFolder, const nsString& aSubdir, PRInt32 aMode, PRInt32* aReturn); PRInt32 AddDirectory(const nsString& aRegName, const nsString& aVersion, const nsString& aJarSource, nsInstallFolder* aFolder, const nsString& aSubdir, PRInt32* aReturn); PRInt32 AddDirectory(const nsString& aRegName, const nsString& aJarSource, nsInstallFolder* aFolder, const nsString& aSubdir, PRInt32* aReturn); PRInt32 AddDirectory(const nsString& aJarSource, PRInt32* aReturn); PRInt32 AddSubcomponent(const nsString& aRegName, const nsString& aVersion, const nsString& aJarSource, nsInstallFolder *aFolder, const nsString& aTargetName, PRInt32 aMode, PRInt32* aReturn); PRInt32 AddSubcomponent(const nsString& aRegName, const nsString& aVersion, const nsString& aJarSource, nsInstallFolder *aFolder, const nsString& aTargetName, PRInt32* aReturn); PRInt32 AddSubcomponent(const nsString& aRegName, const nsString& aJarSource, nsInstallFolder *aFolder, const nsString& aTargetName, PRInt32* aReturn); PRInt32 AddSubcomponent(const nsString& aJarSource, PRInt32* aReturn); PRInt32 DiskSpaceAvailable(const nsString& aFolder, PRInt64* aReturn); PRInt32 Execute(const nsString& aJarSource, const nsString& aArgs, PRBool aBlocking, PRInt32* aReturn); PRInt32 FinalizeInstall(PRInt32* aReturn); PRInt32 Gestalt(const nsString& aSelector, PRInt32* aReturn); PRInt32 GetComponentFolder(const nsString& aComponentName, const nsString& aSubdirectory, nsInstallFolder** aFolder); PRInt32 GetComponentFolder(const nsString& aComponentName, nsInstallFolder** aFolder); PRInt32 GetFolder(nsInstallFolder& aTargetFolder, const nsString& aSubdirectory, nsInstallFolder** aFolder); PRInt32 GetFolder(const nsString& aTargetFolder, const nsString& aSubdirectory, nsInstallFolder** aFolder); PRInt32 GetFolder(const nsString& aTargetFolder, nsInstallFolder** aFolder); PRInt32 GetLastError(PRInt32* aReturn); PRInt32 GetWinProfile(const nsString& aFolder, const nsString& aFile, JSContext* jscontext, JSClass* WinProfileClass, jsval* aReturn); PRInt32 GetWinRegistry(JSContext* jscontext, JSClass* WinRegClass, jsval* aReturn); PRInt32 LoadResources(JSContext* cx, const nsString& aBaseName, jsval* aReturn); PRInt32 Patch(const nsString& aRegName, const nsString& aVersion, const nsString& aJarSource, nsInstallFolder* aFolder, const nsString& aTargetName, PRInt32* aReturn); PRInt32 Patch(const nsString& aRegName, const nsString& aJarSource, nsInstallFolder* aFolder, const nsString& aTargetName, PRInt32* aReturn); PRInt32 RegisterChrome(nsIFile* chrome, PRUint32 chromeType, const char* path); PRInt32 RefreshPlugins(); PRInt32 ResetError(PRInt32 aError); PRInt32 SetPackageFolder(nsInstallFolder& aFolder); PRInt32 StartInstall(const nsString& aUserPackageName, const nsString& aPackageName, const nsString& aVersion, PRInt32* aReturn); PRInt32 Uninstall(const nsString& aPackageName, PRInt32* aReturn); PRInt32 FileOpDirCreate(nsInstallFolder& aTarget, PRInt32* aReturn); PRInt32 FileOpDirGetParent(nsInstallFolder& aTarget, nsInstallFolder** theParentFolder); PRInt32 FileOpDirRemove(nsInstallFolder& aTarget, PRInt32 aFlags, PRInt32* aReturn); PRInt32 FileOpDirRename(nsInstallFolder& aSrc, nsString& aTarget, PRInt32* aReturn); PRInt32 FileOpFileCopy(nsInstallFolder& aSrc, nsInstallFolder& aTarget, PRInt32* aReturn); PRInt32 FileOpFileDelete(nsInstallFolder& aTarget, PRInt32 aFlags, PRInt32* aReturn); PRInt32 FileOpFileExists(nsInstallFolder& aTarget, PRBool* aReturn); PRInt32 FileOpFileExecute(nsInstallFolder& aTarget, nsString& aParams, PRBool aBlocking, PRInt32* aReturn); PRInt32 FileOpFileGetNativeVersion(nsInstallFolder& aTarget, nsString* aReturn); PRInt32 FileOpFileGetDiskSpaceAvailable(nsInstallFolder& aTarget, PRInt64* aReturn); PRInt32 FileOpFileGetModDate(nsInstallFolder& aTarget, double* aReturn); PRInt32 FileOpFileGetSize(nsInstallFolder& aTarget, PRInt64* aReturn); PRInt32 FileOpFileIsDirectory(nsInstallFolder& aTarget, PRBool* aReturn); PRInt32 FileOpFileIsWritable(nsInstallFolder& aTarget, PRBool* aReturn); PRInt32 FileOpFileIsFile(nsInstallFolder& aTarget, PRBool* aReturn); PRInt32 FileOpFileModDateChanged(nsInstallFolder& aTarget, double aOldStamp, PRBool* aReturn); PRInt32 FileOpFileMove(nsInstallFolder& aSrc, nsInstallFolder& aTarget, PRInt32* aReturn); PRInt32 FileOpFileRename(nsInstallFolder& aSrc, nsString& aTarget, PRInt32* aReturn); PRInt32 FileOpFileWindowsGetShortName(nsInstallFolder& aTarget, nsString& aShortPathName); PRInt32 FileOpFileWindowsShortcut(nsIFile* aTarget, nsIFile* aShortcutPath, nsString& aDescription, nsIFile* aWorkingPath, nsString& aParams, nsIFile* aIcon, PRInt32 aIconId, PRInt32* aReturn); PRInt32 FileOpFileMacAlias(nsIFile *aSourceFile, nsIFile *aAliasFile, PRInt32* aReturn); PRInt32 FileOpFileUnixLink(nsInstallFolder& aTarget, PRInt32 aFlags, PRInt32* aReturn); PRInt32 FileOpWinRegisterServer(nsInstallFolder& aTarget, PRInt32* aReturn); void LogComment(nsString& aComment); PRInt32 ExtractFileFromJar(const nsString& aJarfile, nsIFile* aSuggestedName, nsIFile** aRealName); char* GetResourcedString(const nsAString& aResName); void AddPatch(nsHashKey *aKey, nsIFile* fileName); void GetPatch(nsHashKey *aKey, nsIFile** fileName); nsIFile* GetJarFileLocation() { return mJarFileLocation; } void SetJarFileLocation(nsIFile* aFile); void GetInstallArguments(nsString& args); void SetInstallArguments(const nsString& args); void GetInstallURL(nsString& url); void SetInstallURL(const nsString& url); PRUint32 GetInstallFlags() { return mInstallFlags; } void SetInstallFlags(PRUint32 aFlags) { mInstallFlags = aFlags; } PRInt32 GetInstallPlatform(nsCString& aPlatform); nsIChromeRegistry* GetChromeRegistry() { return mChromeRegistry; } void SetChromeRegistry(nsIChromeRegistry* reg) { mChromeRegistry = reg; } nsIDOMWindowInternal* GetParentDOMWindow() { return mParent; } void SetParentDOMWindow(nsIDOMWindowInternal* parent) { mParent = parent; } PRBool GetStatusSent() { return mStatusSent; } PRBool InInstallTransaction(void) { return mInstalledFiles != 0; } PRInt32 Alert(nsString& string); PRInt32 Confirm(nsString& string, PRBool* aReturn); void InternalAbort(PRInt32 errcode); PRInt32 ScheduleForInstall(nsInstallObject* ob); PRInt32 SaveError(PRInt32 errcode); private: JSObject* mScriptObject; JSObject* mWinRegObject; JSObject* mWinProfileObject; nsCOMPtr mJarFileLocation; nsIZipReader* mJarFileData; nsString mInstallArguments; nsString mInstallURL; PRUint32 mInstallFlags; nsCString mInstallPlatform; nsIChromeRegistry* mChromeRegistry; nsIDOMWindowInternal* mParent; nsInstallFolder* mPackageFolder; PRBool mUserCancelled; PRBool mStatusSent; PRBool mUninstallPackage; PRBool mRegisterPackage; PRBool mStartInstallCompleted; nsString mRegistryPackageName; nsString mUIName; nsInstallVersion* mVersionInfo; nsVoidArray* mInstalledFiles; nsHashtable* mPatchList; nsCOMPtr mListener; nsCOMPtr mUIThreadProxy; nsCOMPtr mStringBundle; PRInt32 mLastError; void ParseFlags(int flags); PRInt32 SanityCheck(void); void GetTime(nsString &aString); nsPIXPIProxy* GetUIThreadProxy(); PRInt32 GetQualifiedRegName(const nsString& name, nsString& qualifiedRegName ); PRInt32 GetQualifiedPackageName( const nsString& name, nsString& qualifiedName ); void CurrentUserNode(nsString& userRegNode); PRBool BadRegName(const nsString& regName); void CleanUp(); PRInt32 ExtractDirEntries(const nsString& directory, nsVoidArray *paths); static void DeleteVector(nsVoidArray* vector); }; nsresult MakeUnique(nsILocalFile* file); PRInt32 RunInstall(nsInstallInfo *installInfo); class nsIStackFrame : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x91d82105, 0x7c62, 0x4f8b, { 0x97, 0x79, 0x15, 0x42, 0x77, 0xc0, 0xee, 0x90 }}; return iid;} virtual nsresult GetLanguage(PRUint32 *aLanguage) = 0; virtual nsresult GetLanguageName(char * *aLanguageName) = 0; virtual nsresult GetFilename(char * *aFilename) = 0; virtual nsresult GetName(char * *aName) = 0; virtual nsresult GetLineNumber(PRInt32 *aLineNumber) = 0; virtual nsresult GetSourceLine(char * *aSourceLine) = 0; virtual nsresult GetCaller(nsIStackFrame * *aCaller) = 0; virtual nsresult ToString(char **_retval) = 0; }; class nsIException : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xf3a8d3b4, 0xc424, 0x4edc, { 0x8b, 0xf6, 0x89, 0x74, 0xc9, 0x83, 0xba, 0x78 }}; return iid;} virtual nsresult GetMessage(char * *aMessage) = 0; virtual nsresult GetResult(nsresult *aResult) = 0; virtual nsresult GetName(char * *aName) = 0; virtual nsresult GetFilename(char * *aFilename) = 0; virtual nsresult GetLineNumber(PRUint32 *aLineNumber) = 0; virtual nsresult GetColumnNumber(PRUint32 *aColumnNumber) = 0; virtual nsresult GetLocation(nsIStackFrame * *aLocation) = 0; virtual nsresult GetInner(nsIException * *aInner) = 0; virtual nsresult GetData(nsISupports * *aData) = 0; virtual nsresult ToString(char **_retval) = 0; }; class nsIXPCException : public nsIException { public: static const nsIID& GetIID() {static const nsIID iid = {0xb2a34010, 0x3983, 0x11d3, { 0x98, 0x88, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} virtual nsresult Initialize(const char *aMessage, nsresult aResult, const char *aName, nsIStackFrame *aLocation, nsISupports *aData, nsIException *aInner) = 0; }; class nsIJSID : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xc86ae131, 0xd101, 0x11d2, { 0x98, 0x41, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} virtual nsresult GetName(char * *aName) = 0; virtual nsresult GetNumber(char * *aNumber) = 0; virtual nsresult GetId(nsID * *aId) = 0; virtual nsresult GetValid(PRBool *aValid) = 0; virtual nsresult Equals(nsIJSID *other, PRBool *_retval) = 0; virtual nsresult Initialize(const char *idString) = 0; virtual nsresult ToString(char **_retval) = 0; }; class nsIJSIID : public nsIJSID { public: static const nsIID& GetIID() {static const nsIID iid = {0xe08dcda0, 0xd651, 0x11d2, { 0x98, 0x43, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} }; class nsIJSCID : public nsIJSID { public: static const nsIID& GetIID() {static const nsIID iid = {0xe3a24a60, 0xd651, 0x11d2, { 0x98, 0x43, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} virtual nsresult CreateInstance(nsISupports **_retval) = 0; virtual nsresult GetService(nsISupports **_retval) = 0; }; class nsIXPCComponents_Interfaces : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x4b62a640, 0xd26c, 0x11d2, { 0x98, 0x42, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} }; class nsIXPCComponents_Classes : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x978ff520, 0xd26c, 0x11d2, { 0x98, 0x42, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} }; class nsIXPCComponents_ClassesByID : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x336a9590, 0x4d19, 0x11d3, { 0x98, 0x93, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} }; class nsIXPCComponents_Results : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x2fc229a0, 0x5860, 0x11d3, { 0x98, 0x99, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} }; class nsIXPCComponents_ID : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x7994a6e0, 0xe028, 0x11d3, { 0x8f, 0x5d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} }; class nsIXPCComponents_Exception : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x5bf039c0, 0xe028, 0x11d3, { 0x8f, 0x5d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} }; class nsIXPCComponents_Constructor : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x88655640, 0xe028, 0x11d3, { 0x8f, 0x5d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} }; class nsIXPCConstructor : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xc814ca20, 0xe0dc, 0x11d3, { 0x8f, 0x5f, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} virtual nsresult GetClassID(nsIJSCID * *aClassID) = 0; virtual nsresult GetInterfaceID(nsIJSIID * *aInterfaceID) = 0; virtual nsresult GetInitializer(char * *aInitializer) = 0; }; class nsIXPCComponents : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x42624f80, 0xd26c, 0x11d2, { 0x98, 0x42, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} virtual nsresult GetInterfaces(nsIXPCComponents_Interfaces * *aInterfaces) = 0; virtual nsresult GetClasses(nsIXPCComponents_Classes * *aClasses) = 0; virtual nsresult GetClassesByID(nsIXPCComponents_ClassesByID * *aClassesByID) = 0; virtual nsresult GetStack(nsIStackFrame * *aStack) = 0; virtual nsresult GetResults(nsIXPCComponents_Results * *aResults) = 0; virtual nsresult GetManager(nsIComponentManager * *aManager) = 0; virtual nsresult GetID(nsIXPCComponents_ID * *aID) = 0; virtual nsresult GetException(nsIXPCComponents_Exception * *aException) = 0; virtual nsresult GetConstructor(nsIXPCComponents_Constructor * *aConstructor) = 0; virtual nsresult IsSuccessCode(nsresult result, PRBool *_retval) = 0; }; class nsXPTMethodInfo; class nsXPTConstant; class nsXPTParamInfo; class nsXPTType; class nsIInterfaceInfo : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x215dbe04, 0x94a7, 0x11d2, { 0xba, 0x58, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}; return iid;} virtual nsresult GetName(char * *aName) = 0; virtual nsresult GetIID(nsIID * *aIID) = 0; virtual nsresult IsScriptable(PRBool *_retval) = 0; virtual nsresult GetParent(nsIInterfaceInfo * *aParent) = 0; virtual nsresult GetMethodCount(PRUint16 *aMethodCount) = 0; virtual nsresult GetConstantCount(PRUint16 *aConstantCount) = 0; virtual nsresult GetMethodInfo(PRUint16 index, const nsXPTMethodInfo * *info) = 0; virtual nsresult GetMethodInfoForName(const char *methodName, PRUint16 *index, const nsXPTMethodInfo * *info) = 0; virtual nsresult GetConstant(PRUint16 index, const nsXPTConstant * *constant) = 0; virtual nsresult GetInfoForParam(PRUint16 methodIndex, const nsXPTParamInfo * param, nsIInterfaceInfo **_retval) = 0; virtual nsresult GetIIDForParam(PRUint16 methodIndex, const nsXPTParamInfo * param, nsIID * *_retval) = 0; virtual nsresult GetTypeForParam(PRUint16 methodIndex, const nsXPTParamInfo * param, PRUint16 dimension, nsXPTType *_retval) = 0; virtual nsresult GetSizeIsArgNumberForParam(PRUint16 methodIndex, const nsXPTParamInfo * param, PRUint16 dimension, PRUint8 *_retval) = 0; virtual nsresult GetLengthIsArgNumberForParam(PRUint16 methodIndex, const nsXPTParamInfo * param, PRUint16 dimension, PRUint8 *_retval) = 0; virtual nsresult GetInterfaceIsArgNumberForParam(PRUint16 methodIndex, const nsXPTParamInfo * param, PRUint8 *_retval) = 0; virtual nsresult IsIID(const nsIID * IID, PRBool *_retval) = 0; virtual nsresult GetNameShared(const char **name) = 0; virtual nsresult GetIIDShared(const nsIID * *iid) = 0; virtual nsresult IsFunction(PRBool *_retval) = 0; virtual nsresult HasAncestor(const nsIID * iid, PRBool *_retval) = 0; virtual nsresult GetIIDForParamNoAlloc(PRUint16 methodIndex, const nsXPTParamInfo * param, nsIID *iid) = 0; }; class nsIInterfaceInfoManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x8b161900, 0xbe2b, 0x11d2, { 0x98, 0x31, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}; return iid;} virtual nsresult GetInfoForIID(const nsIID * iid, nsIInterfaceInfo **_retval) = 0; virtual nsresult GetInfoForName(const char *name, nsIInterfaceInfo **_retval) = 0; virtual nsresult GetIIDForName(const char *name, nsIID * *_retval) = 0; virtual nsresult GetNameForIID(const nsIID * iid, char **_retval) = 0; virtual nsresult EnumerateInterfaces(nsIEnumerator **_retval) = 0; virtual nsresult AutoRegisterInterfaces(void) = 0; virtual nsresult EnumerateInterfacesWhoseNamesStartWith(const char *prefix, nsIEnumerator **_retval) = 0; }; class nsIExceptionProvider : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x0577744c, 0xc1d2, 0x47f2, { 0x8b, 0xcc, 0xce, 0x7a, 0x9e, 0x5a, 0x88, 0xfc }}; return iid;} virtual nsresult GetException(nsresult result, nsIException *defaultException, nsIException **_retval) = 0; }; class nsIExceptionManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xefc9d00b, 0x231c, 0x4feb, { 0x85, 0x2c, 0xac, 0x01, 0x72, 0x66, 0xa4, 0x15 }}; return iid;} virtual nsresult SetCurrentException(nsIException *error) = 0; virtual nsresult GetCurrentException(nsIException **_retval) = 0; virtual nsresult GetExceptionFromProvider(nsresult rc, nsIException *defaultException, nsIException **_retval) = 0; }; class nsIExceptionService : public nsIExceptionManager { public: static const nsIID& GetIID() {static const nsIID iid = {0x35a88f54, 0xf267, 0x4414, { 0x92, 0xa7, 0x19, 0x1f, 0x64, 0x54, 0xab, 0x52 }}; return iid;} virtual nsresult GetCurrentExceptionManager(nsIExceptionManager * *aCurrentExceptionManager) = 0; virtual nsresult RegisterExceptionProvider(nsIExceptionProvider *provider, PRUint32 moduleCode) = 0; virtual nsresult UnregisterExceptionProvider(nsIExceptionProvider *provider, PRUint32 moduleCode) = 0; }; extern "C" { typedef struct XPTArena XPTArena; XPTArena * XPT_NewArena(PRUint32 block_size, size_t alignment, const char* name); void XPT_DestroyArena(XPTArena *arena); void XPT_DumpStats(XPTArena *arena); void * XPT_ArenaMalloc(XPTArena *arena, size_t size); char * XPT_ArenaStrDup(XPTArena *arena, const char * s); void XPT_NotifyDoneLoading(XPTArena *arena); void XPT_ArenaFree(XPTArena *arena, void* block); void XPT_AssertFailed(const char *s, const char *file, PRUint32 lineno); } extern "C" { typedef struct XPTHeader XPTHeader; typedef struct XPTInterfaceDirectoryEntry XPTInterfaceDirectoryEntry; typedef struct XPTInterfaceDescriptor XPTInterfaceDescriptor; typedef struct XPTConstDescriptor XPTConstDescriptor; typedef struct XPTMethodDescriptor XPTMethodDescriptor; typedef struct XPTParamDescriptor XPTParamDescriptor; typedef struct XPTTypeDescriptor XPTTypeDescriptor; typedef struct XPTTypeDescriptorPrefix XPTTypeDescriptorPrefix; typedef struct XPTString XPTString; typedef struct XPTAnnotation XPTAnnotation; struct XPTHeader { PRUint8 magic[16]; PRUint8 major_version; PRUint8 minor_version; PRUint16 num_interfaces; PRUint32 file_length; XPTInterfaceDirectoryEntry *interface_directory; PRUint32 data_pool; XPTAnnotation *annotations; }; extern XPTHeader * XPT_NewHeader(XPTArena *arena, PRUint16 num_interfaces); extern void XPT_FreeHeader(XPTArena *arena, XPTHeader* aHeader); extern PRUint32 XPT_SizeOfHeader(XPTHeader *header); extern PRUint32 XPT_SizeOfHeaderBlock(XPTHeader *header); struct XPTInterfaceDirectoryEntry { nsID iid; char *name; char *name_space; XPTInterfaceDescriptor *interface_descriptor; }; extern PRBool XPT_FillInterfaceDirectoryEntry(XPTArena *arena, XPTInterfaceDirectoryEntry *ide, nsID *iid, char *name, char *name_space, XPTInterfaceDescriptor *descriptor); extern void XPT_DestroyInterfaceDirectoryEntry(XPTArena *arena, XPTInterfaceDirectoryEntry* ide); struct XPTInterfaceDescriptor { PRUint16 parent_interface; PRUint16 num_methods; XPTMethodDescriptor *method_descriptors; PRUint16 num_constants; XPTConstDescriptor *const_descriptors; PRUint8 flags; XPTTypeDescriptor *additional_types; PRUint16 num_additional_types; }; extern PRBool XPT_GetInterfaceIndexByName(XPTInterfaceDirectoryEntry *ide_block, PRUint16 num_interfaces, char *name, PRUint16 *indexp); extern XPTInterfaceDescriptor * XPT_NewInterfaceDescriptor(XPTArena *arena, PRUint16 parent_interface, PRUint16 num_methods, PRUint16 num_constants, PRUint8 flags); extern void XPT_FreeInterfaceDescriptor(XPTArena *arena, XPTInterfaceDescriptor* id); extern PRBool XPT_InterfaceDescriptorAddTypes(XPTArena *arena, XPTInterfaceDescriptor *id, PRUint16 num); extern PRBool XPT_InterfaceDescriptorAddMethods(XPTArena *arena, XPTInterfaceDescriptor *id, PRUint16 num); extern PRBool XPT_InterfaceDescriptorAddConsts(XPTArena *arena, XPTInterfaceDescriptor *id, PRUint16 num); struct XPTString { PRUint16 length; char *bytes; }; extern XPTString * XPT_NewString(XPTArena *arena, PRUint16 length, char *bytes); extern XPTString * XPT_NewStringZ(XPTArena *arena, char *bytes); struct XPTTypeDescriptorPrefix { PRUint8 flags; }; enum XPTTypeDescriptorTags { TD_INT8 = 0, TD_INT16 = 1, TD_INT32 = 2, TD_INT64 = 3, TD_UINT8 = 4, TD_UINT16 = 5, TD_UINT32 = 6, TD_UINT64 = 7, TD_FLOAT = 8, TD_DOUBLE = 9, TD_BOOL = 10, TD_CHAR = 11, TD_WCHAR = 12, TD_VOID = 13, TD_PNSIID = 14, TD_DOMSTRING = 15, TD_PSTRING = 16, TD_PWSTRING = 17, TD_INTERFACE_TYPE = 18, TD_INTERFACE_IS_TYPE = 19, TD_ARRAY = 20, TD_PSTRING_SIZE_IS = 21, TD_PWSTRING_SIZE_IS = 22 }; struct XPTTypeDescriptor { XPTTypeDescriptorPrefix prefix; PRUint8 argnum; PRUint8 argnum2; union { PRUint16 iface; PRUint16 additional_type; } type; }; union XPTConstValue { PRInt8 i8; PRUint8 ui8; PRInt16 i16; PRUint16 ui16; PRInt32 i32; PRUint32 ui32; PRInt64 i64; PRUint64 ui64; float flt; double dbl; PRBool bul; char ch; PRUint16 wch; nsID *iid; XPTString *string; char *str; PRUint16 *wstr; }; struct XPTConstDescriptor { char *name; XPTTypeDescriptor type; union XPTConstValue value; }; struct XPTParamDescriptor { PRUint8 flags; XPTTypeDescriptor type; }; extern PRBool XPT_FillParamDescriptor(XPTArena *arena, XPTParamDescriptor *pd, PRUint8 flags, XPTTypeDescriptor *type); struct XPTMethodDescriptor { PRUint8 flags; char *name; PRUint8 num_args; XPTParamDescriptor *params; XPTParamDescriptor *result; }; extern PRBool XPT_FillMethodDescriptor(XPTArena *arena, XPTMethodDescriptor *meth, PRUint8 flags, char *name, PRUint8 num_args); struct XPTAnnotation { XPTAnnotation *next; PRUint8 flags; XPTString *creator; XPTString *private_data; }; extern XPTAnnotation * XPT_NewAnnotation(XPTArena *arena, PRUint8 flags, XPTString *creator, XPTString *private_data); } class nsIInterfaceInfoManager; extern "C" { nsIInterfaceInfoManager* XPTI_GetInterfaceInfoManager(); void XPTI_FreeInterfaceInfoManager(); } class nsXPTType : public XPTTypeDescriptorPrefix { public: nsXPTType() {} nsXPTType(const XPTTypeDescriptorPrefix& prefix) {*(XPTTypeDescriptorPrefix*)this = prefix;} nsXPTType(const uint8& prefix) {*(uint8*)this = prefix;} nsXPTType& operator=(uint8 val) {flags = val; return *this;} nsXPTType& operator=(const nsXPTType& other) {flags = other.flags; return *this;} operator uint8() const {return flags;} PRBool IsPointer() const {return (PRBool) ((flags & 0x80));} PRBool IsUniquePointer() const {return (PRBool) ((flags & 0x40));} PRBool IsReference() const {return (PRBool) ((flags & 0x20));} PRBool IsArithmetic() const {return flags <= T_WCHAR;} PRBool IsInterfacePointer() const { switch (TagPart()) { default: return 0; case T_INTERFACE: case T_INTERFACE_IS: return 1; } } PRBool IsArray() const {return (PRBool) TagPart() == T_ARRAY;} PRBool IsDependent() const { switch (TagPart()) { default: return 0; case T_INTERFACE_IS: case TD_ARRAY: case T_PSTRING_SIZE_IS: case T_PWSTRING_SIZE_IS: return 1; } } uint8 TagPart() const {return (uint8) (flags & (~0xe0));} enum { T_I8 = TD_INT8 , T_I16 = TD_INT16 , T_I32 = TD_INT32 , T_I64 = TD_INT64 , T_U8 = TD_UINT8 , T_U16 = TD_UINT16 , T_U32 = TD_UINT32 , T_U64 = TD_UINT64 , T_FLOAT = TD_FLOAT , T_DOUBLE = TD_DOUBLE , T_BOOL = TD_BOOL , T_CHAR = TD_CHAR , T_WCHAR = TD_WCHAR , T_VOID = TD_VOID , T_IID = TD_PNSIID , T_DOMSTRING = TD_DOMSTRING , T_CHAR_STR = TD_PSTRING , T_WCHAR_STR = TD_PWSTRING , T_INTERFACE = TD_INTERFACE_TYPE , T_INTERFACE_IS = TD_INTERFACE_IS_TYPE, T_ARRAY = TD_ARRAY , T_PSTRING_SIZE_IS = TD_PSTRING_SIZE_IS , T_PWSTRING_SIZE_IS = TD_PWSTRING_SIZE_IS }; }; class nsXPTParamInfo : public XPTParamDescriptor { public: nsXPTParamInfo(const XPTParamDescriptor& desc) {*(XPTParamDescriptor*)this = desc;} PRBool IsIn() const {return 0 != ((flags & 0x80));} PRBool IsOut() const {return 0 != ((flags & 0x40));} PRBool IsRetval() const {return 0 != ((flags & 0x20));} PRBool IsShared() const {return 0 != ((flags & 0x10));} PRBool IsDipper() const {return 0 != ((flags & 0x08));} const nsXPTType GetType() const {return type.prefix;} private: nsXPTParamInfo(); }; class nsXPTMethodInfo : public XPTMethodDescriptor { public: nsXPTMethodInfo(const XPTMethodDescriptor& desc) {*(XPTMethodDescriptor*)this = desc;} PRBool IsGetter() const {return 0 != ((flags & 0x80) );} PRBool IsSetter() const {return 0 != ((flags & 0x40) );} PRBool IsNotXPCOM() const {return 0 != ((flags & 0x20));} PRBool IsConstructor() const {return 0 != ((flags & 0x10) );} PRBool IsHidden() const {return 0 != ((flags & 0x08) );} const char* GetName() const {return name;} uint8 GetParamCount() const {return num_args;} const nsXPTParamInfo GetParam(uint8 idx) const { if (!(idx < GetParamCount())) nsDebug::PreCondition("bad arg", "idx < GetParamCount()", "../../dist/include/xpcom/xptinfo.h", 223); return params[idx]; } const nsXPTParamInfo GetResult() const {return *result;} private: nsXPTMethodInfo(); }; struct nsXPTCMiniVariant; class nsXPTConstant : public XPTConstDescriptor { public: nsXPTConstant(const XPTConstDescriptor& desc) {*(XPTConstDescriptor*)this = desc;} const char* GetName() const {return name;} const nsXPTType GetType() const {return type.prefix;} const nsXPTCMiniVariant* GetValue() const {return (nsXPTCMiniVariant*) &value;} private: nsXPTConstant(); }; class nsIXPCScriptable; class nsIXPConnect; class nsIXPConnectWrappedNative; class nsIInterfaceInfo; class nsIXPCSecurityManager; class nsIXPConnectJSObjectHolder : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x8916a320, 0xd118, 0x11d3, { 0x8f, 0x3a, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} virtual nsresult GetJSObject(JSObject * *aJSObject) = 0; }; class nsIXPConnectWrappedNative : public nsIXPConnectJSObjectHolder { public: static const nsIID& GetIID() {static const nsIID iid = {0x215dbe02, 0x94a7, 0x11d2, { 0xba, 0x58, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}; return iid;} virtual nsresult GetNative(nsISupports * *aNative) = 0; virtual nsresult GetJSObjectPrototype(JSObject * *aJSObjectPrototype) = 0; virtual nsresult GetXPConnect(nsIXPConnect * *aXPConnect) = 0; virtual nsresult FindInterfaceWithMember(jsval nameID, nsIInterfaceInfo **_retval) = 0; virtual nsresult FindInterfaceWithName(jsval nameID, nsIInterfaceInfo **_retval) = 0; virtual nsresult DebugDump(PRInt16 depth) = 0; virtual nsresult RefreshPrototype(void) = 0; }; class nsIXPConnectWrappedJS : public nsIXPConnectJSObjectHolder { public: static const nsIID& GetIID() {static const nsIID iid = {0xbed52030, 0xbca6, 0x11d2, { 0xba, 0x79, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}; return iid;} virtual nsresult GetInterfaceInfo(nsIInterfaceInfo * *aInterfaceInfo) = 0; virtual nsresult GetIID(nsIID * *aIID) = 0; virtual nsresult DebugDump(PRInt16 depth) = 0; virtual nsresult AggregatedQueryInterface(const nsIID & uuid, void * *result) = 0; }; class nsIXPCNativeCallContext : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x0fa68a60, 0x8289, 0x11d3, { 0xbb, 0x1a, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}; return iid;} virtual nsresult GetCallee(nsISupports * *aCallee) = 0; virtual nsresult GetCalleeMethodIndex(PRUint16 *aCalleeMethodIndex) = 0; virtual nsresult GetCalleeWrapper(nsIXPConnectWrappedNative * *aCalleeWrapper) = 0; virtual nsresult GetJSContext(JSContext * *aJSContext) = 0; virtual nsresult GetArgc(PRUint32 *aArgc) = 0; virtual nsresult GetArgvPtr(jsval * *aArgvPtr) = 0; virtual nsresult GetRetValPtr(jsval * *aRetValPtr) = 0; virtual nsresult GetExceptionWasThrown(PRBool *aExceptionWasThrown) = 0; virtual nsresult SetExceptionWasThrown(PRBool aExceptionWasThrown) = 0; virtual nsresult GetReturnValueWasSet(PRBool *aReturnValueWasSet) = 0; virtual nsresult SetReturnValueWasSet(PRBool aReturnValueWasSet) = 0; virtual nsresult GetCalleeInterface(nsIInterfaceInfo * *aCalleeInterface) = 0; virtual nsresult GetCalleeClassInfo(nsIClassInfo * *aCalleeClassInfo) = 0; }; class nsIXPCWrappedJSObjectGetter : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x254bb2e0, 0x6439, 0x11d4, { 0x8f, 0xe0, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} virtual nsresult GetNeverCalled(nsISupports * *aNeverCalled) = 0; }; class nsIXPCFunctionThisTranslator : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x039ef260, 0x2a0d, 0x11d5, { 0x90, 0xa7, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}; return iid;} virtual nsresult TranslateThis(nsISupports *aInitialThis, nsIInterfaceInfo *aInterfaceInfo, PRUint16 aMethodIndex, PRBool *aHideFirstParamFromJS, nsIID * *aIIDOfResult, nsISupports **_retval) = 0; }; class nsIXPConnect : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xefae37b0, 0x946d, 0x11d2, { 0xba, 0x58, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}; return iid;} static const nsID& GetCID() {static const nsID cid = { 0xcb6593e0, 0xf9b2, 0x11d2, { 0xbd, 0xd6, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74 } }; return cid;} virtual nsresult InitClasses(JSContext * aJSContext, JSObject * aGlobalJSObj) = 0; virtual nsresult InitClassesWithNewWrappedGlobal(JSContext * aJSContext, nsISupports *aCOMObj, const nsIID & aIID, PRBool aCallJS_InitStandardClasses, nsIXPConnectJSObjectHolder **_retval) = 0; virtual nsresult WrapNative(JSContext * aJSContext, JSObject * aScope, nsISupports *aCOMObj, const nsIID & aIID, nsIXPConnectJSObjectHolder **_retval) = 0; virtual nsresult WrapJS(JSContext * aJSContext, JSObject * aJSObj, const nsIID & aIID, void * *result) = 0; virtual nsresult GetWrappedNativeOfJSObject(JSContext * aJSContext, JSObject * aJSObj, nsIXPConnectWrappedNative **_retval) = 0; virtual nsresult SetSecurityManagerForJSContext(JSContext * aJSContext, nsIXPCSecurityManager *aManager, PRUint16 flags) = 0; virtual nsresult GetSecurityManagerForJSContext(JSContext * aJSContext, nsIXPCSecurityManager **aManager, PRUint16 *flags) = 0; virtual nsresult SetDefaultSecurityManager(nsIXPCSecurityManager *aManager, PRUint16 flags) = 0; virtual nsresult GetDefaultSecurityManager(nsIXPCSecurityManager **aManager, PRUint16 *flags) = 0; virtual nsresult CreateStackFrameLocation(PRUint32 aLanguage, const char *aFilename, const char *aFunctionName, PRInt32 aLineNumber, nsIStackFrame *aCaller, nsIStackFrame **_retval) = 0; virtual nsresult SyncJSContexts(void) = 0; virtual nsresult GetCurrentJSStack(nsIStackFrame * *aCurrentJSStack) = 0; virtual nsresult GetCurrentNativeCallContext(nsIXPCNativeCallContext * *aCurrentNativeCallContext) = 0; virtual nsresult GetPendingException(nsIException * *aPendingException) = 0; virtual nsresult SetPendingException(nsIException * aPendingException) = 0; virtual nsresult DebugDump(PRInt16 depth) = 0; virtual nsresult DebugDumpObject(nsISupports *aCOMObj, PRInt16 depth) = 0; virtual nsresult DebugDumpJSStack(PRBool showArgs, PRBool showLocals, PRBool showThisProps) = 0; virtual nsresult DebugDumpEvalInJSStackFrame(PRUint32 aFrameNumber, const char *aSourceText) = 0; virtual nsresult SetSafeJSContextForCurrentThread(JSContext * cx) = 0; virtual nsresult WrapJSAggregatedToNative(nsISupports *aOuter, JSContext * aJSContext, JSObject * aJSObj, const nsIID & aIID, void * *result) = 0; virtual nsresult GetWrappedNativeOfNativeObject(JSContext * aJSContext, JSObject * aScope, nsISupports *aCOMObj, const nsIID & aIID, nsIXPConnectWrappedNative **_retval) = 0; virtual nsresult GetFunctionThisTranslator(const nsIID & aIID, nsIXPCFunctionThisTranslator **_retval) = 0; virtual nsresult SetFunctionThisTranslator(const nsIID & aIID, nsIXPCFunctionThisTranslator *aTranslator, nsIXPCFunctionThisTranslator **_retval) = 0; virtual nsresult ReparentWrappedNativeIfFound(JSContext * aJSContext, JSObject * aScope, JSObject * aNewParent, nsISupports *aCOMObj, nsIXPConnectJSObjectHolder **_retval) = 0; virtual nsresult ClearAllWrappedNativeSecurityPolicies(void) = 0; virtual nsresult GetWrappedNativePrototype(JSContext * aJSContext, JSObject * aScope, nsIClassInfo *aClassInfo, nsIXPConnectJSObjectHolder **_retval) = 0; virtual nsresult GetCollectGarbageOnMainThreadOnly(PRBool *aCollectGarbageOnMainThreadOnly) = 0; virtual nsresult SetCollectGarbageOnMainThreadOnly(PRBool aCollectGarbageOnMainThreadOnly) = 0; virtual nsresult GetDeferReleasesUntilAfterGarbageCollection(PRBool *aDeferReleasesUntilAfterGarbageCollection) = 0; virtual nsresult SetDeferReleasesUntilAfterGarbageCollection(PRBool aDeferReleasesUntilAfterGarbageCollection) = 0; virtual nsresult ReleaseJSContext(JSContext * aJSContext, PRBool noGC) = 0; }; typedef struct XPITriggerEvent { PLEvent e; nsString URL; PRInt32 status; JSContext* cx; jsval global; jsval cbval; nsCOMPtr ref; } XPITriggerEvent; class nsXPITriggerItem { public: nsXPITriggerItem( const PRUnichar* name, const PRUnichar* URL, PRInt32 flags = 0); ~nsXPITriggerItem(); nsString mName; nsString mURL; nsString mArguments; PRInt32 mFlags; nsCOMPtr mFile; nsCOMPtr mOutStream; PRBool IsFileURL() { return Substring(mURL, 0, 6).Equals(static_cast< const nsAFlatString& >(nsDependentString(reinterpret_cast< const nsAString::char_type* >(L"file:/"), PRUint32((sizeof(L"file:/")/sizeof(wchar_t))-1)))); } PRBool IsRelativeURL(); private: nsXPITriggerItem& operator=(const nsXPITriggerItem& rhs); nsXPITriggerItem(const nsXPITriggerItem& rhs); }; class nsXPITriggerInfo { public: nsXPITriggerInfo(); ~nsXPITriggerInfo(); void Add( nsXPITriggerItem *aItem ) { if ( aItem ) mItems.AppendElement( (void*)aItem ); } nsXPITriggerItem* Get( PRUint32 aIndex ) { return (nsXPITriggerItem*)mItems.ElementAt(aIndex);} void SaveCallback( JSContext *aCx, jsval aVal ); PRUint32 Size() { return mItems.Count(); } void SendStatus(const PRUnichar* URL, PRInt32 status); private: nsVoidArray mItems; JSContext *mCx; nsCOMPtr mGlobalWrapper; jsval mCbval; PRThread* mThread; nsXPITriggerInfo& operator=(const nsXPITriggerInfo& rhs); nsXPITriggerInfo(const nsXPITriggerInfo& rhs); }; class nsIDOMInstallTriggerGlobal : public nsISupports { public: static const nsIID& GetIID() { static nsIID iid = { 0x18c2f987, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53}}; return iid; } enum { MAJOR_DIFF = 4, MINOR_DIFF = 3, REL_DIFF = 2, BLD_DIFF = 1, EQUAL = 0 }; virtual nsresult UpdateEnabled(PRBool* aReturn)=0; virtual nsresult Install(nsIScriptGlobalObject* globalObject, nsXPITriggerInfo* aInfo, PRBool* aReturn)=0; virtual nsresult InstallChrome(nsIScriptGlobalObject* globalObject, PRUint32 aType, nsXPITriggerItem* aItem, PRBool* aReturn)=0; virtual nsresult StartSoftwareUpdate(nsIScriptGlobalObject* globalObject, const nsString& aURL, PRInt32 aFlags, PRBool* aReturn)=0; virtual nsresult CompareVersion(const nsString& aRegName, PRInt32 aMajor, PRInt32 aMinor, PRInt32 aRelease, PRInt32 aBuild, PRInt32* aReturn)=0; virtual nsresult CompareVersion(const nsString& aRegName, const nsString& aVersion, PRInt32* aReturn)=0; virtual nsresult CompareVersion(const nsString& aRegName, nsIDOMInstallVersion* aVersion, PRInt32* aReturn)=0; virtual nsresult GetVersion(const nsString& component, nsString& version)=0; }; extern nsresult NS_InitInstallTriggerGlobalClass(nsIScriptContext *aContext, void **aPrototype); extern "C" nsresult NS_NewScriptInstallTriggerGlobal(nsIScriptContext *aContext, nsISupports *aSupports, nsISupports *aParent, void **aReturn); class nsIRequest; class nsIContentHandler : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x2f0f927a, 0x8677, 0x11d3, { 0x98, 0x9d, 0x00, 0x10, 0x83, 0x01, 0x0e, 0x9b }}; return iid;} virtual nsresult HandleContent(const char *aContentType, const char *aCommand, nsISupports *aWindowContext, nsIRequest *aRequest) = 0; }; class nsInstallTrigger: public nsIScriptObjectOwner, public nsIDOMInstallTriggerGlobal, public nsIContentHandler { public: static const nsIID& IID() { static nsIID iid = { 0x18c2f98d, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }; return iid; } nsInstallTrigger(); virtual ~nsInstallTrigger(); public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult HandleContent(const char *aContentType, const char *aCommand, nsISupports *aWindowContext, nsIRequest *aRequest); virtual nsresult GetScriptObject(nsIScriptContext *aContext, void** aScriptObject); virtual nsresult SetScriptObject(void* aScriptObject); virtual nsresult UpdateEnabled(PRBool* aReturn); virtual nsresult Install(nsIScriptGlobalObject* aGlobalObject, nsXPITriggerInfo *aInfo, PRBool* aReturn); virtual nsresult InstallChrome(nsIScriptGlobalObject* aGlobalObject, PRUint32 aType, nsXPITriggerItem* aItem, PRBool* aReturn); virtual nsresult StartSoftwareUpdate(nsIScriptGlobalObject* aGlobalObject, const nsString& aURL, PRInt32 aFlags, PRInt32* aReturn); virtual nsresult CompareVersion(const nsString& aRegName, PRInt32 aMajor, PRInt32 aMinor, PRInt32 aRelease, PRInt32 aBuild, PRInt32* aReturn); virtual nsresult CompareVersion(const nsString& aRegName, const nsString& aVersion, PRInt32* aReturn); virtual nsresult CompareVersion(const nsString& aRegName, nsIDOMInstallVersion* aVersion, PRInt32* aReturn); virtual nsresult GetVersion(const nsString& component, nsString& version); private: void *mScriptObject; virtual nsresult InitRegistry(void); }; extern "C" { PRInt32 DeleteFileNowOrSchedule(nsIFile* filename); PRInt32 ReplaceFileNowOrSchedule(nsIFile* tmpfile, nsIFile* target ); PRInt32 ScheduleFileForDeletion(nsIFile* filename); char* GetRegFilePath(); void PerformScheduledTasks(HREG reg); } class nsISeekableStream : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xe9de5df0, 0xc7ec, 0x11d3, { 0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }}; return iid;} enum { NS_SEEK_SET = 0 }; enum { NS_SEEK_CUR = 1 }; enum { NS_SEEK_END = 2 }; virtual nsresult Seek(PRInt32 whence, PRInt32 offset) = 0; virtual nsresult Tell(PRUint32 *_retval) = 0; virtual nsresult SetEOF(void) = 0; }; class nsFileSpec; class nsIOpenFile : public nsISupports { public: static const nsIID& GetIID() { static nsIID iid = { 0xa6cf90e8, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32} }; return iid; } virtual nsresult Open( const nsFileSpec& inFile, int nsprMode, PRIntn accessMode) = 0; virtual nsresult GetIsOpen(PRBool* outOpen) = 0; }; class nsIRandomAccessStore : public nsISeekableStream { public: static const nsIID& GetIID() { static nsIID iid = { 0xa6cf90eb, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32} }; return iid; } virtual nsresult GetAtEOF(PRBool* outAtEOF) = 0; virtual nsresult SetAtEOF(PRBool inAtEOF) = 0; }; class nsIFileSpecInputStream : public nsIInputStream { public: static const nsIID& GetIID() { static nsIID iid = { 0xa6cf90e6, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32} }; return iid; } }; class nsIFileSpecOutputStream : public nsIOutputStream { public: static const nsIID& GetIID() { static nsIID iid = { 0xa6cf90e7, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32} }; return iid; } }; extern "C" nsresult NS_NewTypicalInputFileStream( nsISupports** aStreamResult, const nsFileSpec& inFile ); extern "C" nsresult NS_NewOutputConsoleStream( nsISupports** aStreamResult); extern "C" nsresult NS_NewTypicalOutputFileStream( nsISupports** aStreamResult, const nsFileSpec& inFile ); extern "C" nsresult NS_NewTypicalIOFileStream( nsISupports** aStreamResult, const nsFileSpec& inFile ); extern "C" nsresult NS_NewIOFileStream( nsISupports** aStreamResult, const nsFileSpec& inFile, PRInt32 nsprMode, PRInt32 accessMode); class nsFileSpec; class nsString; class nsIInputStream; class nsIOutputStream; class nsIFileSpec; class istream; class ostream; class nsInputStream { public: nsInputStream(nsIInputStream* inStream) : mInputStream(do_QueryInterface(inStream)) , mEOF(0) {} virtual ~nsInputStream(); nsCOMPtr GetIStream() const { return mInputStream; } PRBool eof() const { return get_at_eof(); } char get(); nsresult close() { if (!(mInputStream)) nsDebug::Assertion("mInputStream is null!", "mInputStream", "../../dist/include/xpcom/nsFileStream.h", 198); if (mInputStream) { return mInputStream->Close(); } return 0; } PRInt32 read(void* s, PRInt32 n); nsInputStream& operator >> (char& ch); nsInputStream& operator >> (nsInputStream& (*pf)(nsInputStream&)) { return pf(*this); } protected: virtual void set_at_eof(PRBool atEnd) { mEOF = atEnd; } virtual PRBool get_at_eof() const { return mEOF; } private: nsInputStream& operator >> (char* buf); nsInputStream(const nsInputStream& rhs); nsInputStream& operator=(const nsInputStream& rhs); protected: nsCOMPtr mInputStream; PRBool mEOF; }; typedef nsInputStream nsBasicInStream; class nsOutputStream { public: nsOutputStream() {} nsOutputStream(nsIOutputStream* inStream) : mOutputStream(do_QueryInterface(inStream)) {} virtual ~nsOutputStream(); nsCOMPtr GetIStream() const { return mOutputStream; } nsresult close() { if (mOutputStream) return mOutputStream->Close(); return 0; } void put(char c); PRInt32 write(const void* s, PRInt32 n); virtual nsresult flush(); nsOutputStream& operator << (const char* buf); nsOutputStream& operator << (char ch); nsOutputStream& operator << (short val); nsOutputStream& operator << (unsigned short val); nsOutputStream& operator << (long val); nsOutputStream& operator << (unsigned long val); nsOutputStream& operator << (int val); nsOutputStream& operator << (unsigned int val); nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return pf(*this); } private: nsOutputStream(const nsOutputStream& rhs); nsOutputStream& operator=(const nsOutputStream& rhs); protected: nsCOMPtr mOutputStream; }; typedef nsOutputStream nsBasicOutStream; class nsErrorProne { public: nsErrorProne() : mResult(0) { } PRBool failed() const { return ((mResult) & 0x80000000); } nsresult error() const { return mResult; } protected: nsresult mResult; }; class nsFileClient : public virtual nsErrorProne { public: nsFileClient(const nsCOMPtr& inFile) : mFile(do_QueryInterface(inFile)) { } virtual ~nsFileClient() {} void open( const nsFileSpec& inFile, int nsprMode, PRIntn accessMode) { if (mFile) mResult = mFile->Open(inFile, nsprMode, accessMode); } PRBool is_open() const { PRBool result = 0; if (mFile) mFile->GetIsOpen(&result); return result; } PRBool is_file() const { return mFile ? 1 : 0; } protected: nsFileClient() { } protected: nsCOMPtr mFile; }; class nsRandomAccessStoreClient : public virtual nsErrorProne { public: nsRandomAccessStoreClient() { } nsRandomAccessStoreClient(const nsCOMPtr& inStore) : mStore(do_QueryInterface(inStore)) { } virtual ~nsRandomAccessStoreClient() {} void seek(PRInt32 offset) { seek(PR_SEEK_SET, offset); } void seek(PRSeekWhence whence, PRInt32 offset) { set_at_eof(0); if (mStore) mResult = mStore->Seek(whence, offset); } PRIntn tell() { PRIntn result = -1; if (mStore) mResult = mStore->Tell((PRUint32 *)&result); return result; } protected: virtual PRBool get_at_eof() const { PRBool result = 1; if (mStore) mStore->GetAtEOF(&result); return result; } virtual void set_at_eof(PRBool atEnd) { if (mStore) mStore->SetAtEOF(atEnd); } private: nsRandomAccessStoreClient(const nsRandomAccessStoreClient& rhs); nsRandomAccessStoreClient& operator=(const nsRandomAccessStoreClient& rhs); protected: nsCOMPtr mStore; }; class nsRandomAccessInputStream : public nsRandomAccessStoreClient , public nsInputStream { public: nsRandomAccessInputStream(nsIInputStream* inStream) : nsRandomAccessStoreClient(do_QueryInterface(inStream)) , nsInputStream(inStream) { } PRBool readline(char* s, PRInt32 n); nsInputStream& operator >> (char& ch) { return nsInputStream::operator >>(ch); } nsInputStream& operator >> (nsInputStream& (*pf)(nsInputStream&)) { return nsInputStream::operator >>(pf); } protected: nsRandomAccessInputStream() : nsInputStream(0) { } virtual PRBool get_at_eof() const { return nsRandomAccessStoreClient::get_at_eof(); } virtual void set_at_eof(PRBool atEnd) { nsRandomAccessStoreClient::set_at_eof(atEnd); } private: nsRandomAccessInputStream(const nsRandomAccessInputStream& rhs); nsRandomAccessInputStream& operator=(const nsRandomAccessInputStream& rhs); }; class nsInputStringStream : public nsRandomAccessInputStream { public: nsInputStringStream(const char* stringToRead); nsInputStringStream(const nsString& stringToRead); nsInputStream& operator >> (char& ch) { return nsInputStream::operator >>(ch); } nsInputStream& operator >> (nsInputStream& (*pf)(nsInputStream&)) { return nsInputStream::operator >>(pf); } private: nsInputStringStream(const nsInputStringStream& rhs); nsInputStringStream& operator=(const nsInputStringStream& rhs); }; class nsInputFileStream : public nsRandomAccessInputStream , public nsFileClient { public: enum { kDefaultMode = 0x01 }; nsInputFileStream(nsIInputStream* inStream) : nsRandomAccessInputStream(inStream) , nsFileClient(do_QueryInterface(inStream)) , mFileInputStream(do_QueryInterface(inStream)) { } nsInputFileStream( const nsFileSpec& inFile, int nsprMode = kDefaultMode, PRIntn accessMode = 00666); nsInputFileStream(nsIFileSpec* inFile); virtual ~nsInputFileStream(); void Open( const nsFileSpec& inFile, int nsprMode = kDefaultMode, PRIntn accessMode = 00666) { if (mFile) mFile->Open(inFile, nsprMode, accessMode); } nsInputStream& operator >> (char& ch) { return nsInputStream::operator >>(ch); } nsInputStream& operator >> (nsInputStream& (*pf)(nsInputStream&)) { return nsInputStream::operator >>(pf); } protected: void AssignFrom(nsISupports* stream); private: nsInputFileStream(const nsInputFileStream& rhs); nsInputFileStream& operator=(const nsInputFileStream& rhs); protected: nsCOMPtr mFileInputStream; }; class nsRandomAccessOutputStream : public nsRandomAccessStoreClient , public nsOutputStream { public: nsRandomAccessOutputStream(nsIOutputStream* inStream) : nsRandomAccessStoreClient(do_QueryInterface(inStream)) , nsOutputStream(inStream) { } nsOutputStream& operator << (const char* buf) { return nsOutputStream::operator << (buf); } nsOutputStream& operator << (char ch) { return nsOutputStream::operator << (ch); } nsOutputStream& operator << (short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return nsOutputStream::operator << (pf); } protected: nsRandomAccessOutputStream() : nsOutputStream(0) { } private: nsRandomAccessOutputStream(const nsRandomAccessOutputStream& rhs); nsRandomAccessOutputStream& operator=(const nsRandomAccessOutputStream& rhs); }; class nsOutputStringStream : public nsRandomAccessOutputStream { public: nsOutputStringStream(char*& stringToChange); nsOutputStringStream(nsString& stringToChange); nsOutputStream& operator << (const char* buf) { return nsOutputStream::operator << (buf); } nsOutputStream& operator << (char ch) { return nsOutputStream::operator << (ch); } nsOutputStream& operator << (short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return nsOutputStream::operator << (pf); } private: nsOutputStringStream(const nsOutputStringStream& rhs); nsOutputStringStream& operator=(const nsOutputStringStream& rhs); }; class nsOutputFileStream : public nsRandomAccessOutputStream , public nsFileClient { public: enum { kDefaultMode = (0x02 | 0x08 | 0x20) }; nsOutputFileStream() {} nsOutputFileStream(nsIOutputStream* inStream) { AssignFrom(inStream); } nsOutputFileStream( const nsFileSpec& inFile, int nsprMode = kDefaultMode, PRIntn accessMode = 00666) { nsISupports* stream; if (((NS_NewIOFileStream( &stream, inFile, nsprMode, accessMode)) & 0x80000000)) return; AssignFrom(stream); do { (stream)->Release(); (stream) = 0; } while (0); } nsOutputFileStream(nsIFileSpec* inFile); virtual ~nsOutputFileStream(); virtual nsresult flush(); virtual void abort(); nsOutputStream& operator << (const char* buf) { return nsOutputStream::operator << (buf); } nsOutputStream& operator << (char ch) { return nsOutputStream::operator << (ch); } nsOutputStream& operator << (short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return nsOutputStream::operator << (pf); } protected: void AssignFrom(nsISupports* stream); private: nsOutputFileStream(const nsOutputFileStream& rhs); nsOutputFileStream& operator=(const nsOutputFileStream& rhs); protected: nsCOMPtr mFileOutputStream; }; class nsOutputConsoleStream : public nsOutputFileStream { public: nsOutputConsoleStream() { nsISupports* stream; if (((NS_NewOutputConsoleStream(&stream)) & 0x80000000)) return; mFile = do_QueryInterface(stream); mOutputStream = do_QueryInterface(stream); mFileOutputStream = do_QueryInterface(stream); do { (stream)->Release(); (stream) = 0; } while (0); } nsOutputStream& operator << (const char* buf) { return nsOutputStream::operator << (buf); } nsOutputStream& operator << (char ch) { return nsOutputStream::operator << (ch); } nsOutputStream& operator << (short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return nsOutputStream::operator << (pf); } private: nsOutputConsoleStream(const nsOutputConsoleStream& rhs); nsOutputConsoleStream& operator=(const nsOutputConsoleStream& rhs); }; class nsIOFileStream : public nsInputFileStream , public nsOutputStream { public: enum { kDefaultMode = (0x04 | 0x08) }; nsIOFileStream( nsIInputStream* inInputStream , nsIOutputStream* inOutputStream) : nsInputFileStream(inInputStream) , nsOutputStream(inOutputStream) , mFileOutputStream(do_QueryInterface(inOutputStream)) { } nsIOFileStream( const nsFileSpec& inFile, int nsprMode = kDefaultMode, PRIntn accessMode = 00666) : nsInputFileStream((nsIInputStream*)0) , nsOutputStream(0) { nsISupports* stream; if (((NS_NewIOFileStream( &stream, inFile, nsprMode, accessMode)) & 0x80000000)) return; mFile = do_QueryInterface(stream); mStore = do_QueryInterface(stream); mInputStream = do_QueryInterface(stream); mOutputStream = do_QueryInterface(stream); mFileInputStream = do_QueryInterface(stream); mFileOutputStream = do_QueryInterface(stream); do { (stream)->Release(); (stream) = 0; } while (0); } virtual nsresult close() { return nsInputFileStream::close(); } nsOutputStream& operator << (const char* buf) { return nsOutputStream::operator << (buf); } nsOutputStream& operator << (char ch) { return nsOutputStream::operator << (ch); } nsOutputStream& operator << (short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return nsOutputStream::operator << (pf); } nsInputStream& operator >> (char& ch) { return nsInputStream::operator >>(ch); } nsInputStream& operator >> (nsInputStream& (*pf)(nsInputStream&)) { return nsInputStream::operator >>(pf); } virtual nsresult flush() {if (mFileOutputStream) mFileOutputStream->Flush(); return error(); } private: nsIOFileStream(const nsIOFileStream& rhs); nsIOFileStream& operator=(const nsIOFileStream& rhs); protected: nsCOMPtr mFileOutputStream; }; nsOutputStream& nsEndl(nsOutputStream& os); class nsSaveViaTempStream : public nsOutputFileStream { private: typedef nsOutputFileStream Inherited; public: nsSaveViaTempStream(const nsFileSpec& inFileToSave); ~nsSaveViaTempStream(); virtual void close(); nsOutputStream& operator << (const char* buf) { return nsOutputStream::operator << (buf); } nsOutputStream& operator << (char ch) { return nsOutputStream::operator << (ch); } nsOutputStream& operator << (short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned short val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned long val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (unsigned int val) { return nsOutputStream::operator << (val); } nsOutputStream& operator << (nsOutputStream& (*pf)(nsOutputStream&)) { return nsOutputStream::operator << (pf); } private: nsSaveViaTempStream(const nsSaveViaTempStream& rhs); nsSaveViaTempStream& operator=(const nsSaveViaTempStream& rhs); protected: const nsFileSpec& mFileToSave; nsFileSpec* mTempFileSpec; }; class nsLoggingProgressListener : public nsIXPIListener { public: nsLoggingProgressListener(); virtual ~nsLoggingProgressListener(); public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult BeforeJavascriptEvaluation(const PRUnichar *URL); virtual nsresult AfterJavascriptEvaluation(const PRUnichar *URL); virtual nsresult InstallStarted(const PRUnichar *URL, const PRUnichar *UIPackageName); virtual nsresult ItemScheduled(const PRUnichar *message); virtual nsresult FinalizeProgress(const PRUnichar *message, PRInt32 itemNum, PRInt32 totNum); virtual nsresult FinalStatus(const PRUnichar *URL, PRInt32 status); virtual nsresult LogComment(const PRUnichar *comment); private: void GetTime(char** aString); nsOutputFileStream *mLogStream; }; nsresult Convert_nsIFile_To_nsFileSpec(nsIFile *aInIFile, nsFileSpec **aOutFileSpec); class nsIProcess : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x3ed86dbe, 0xd084, 0x11d4, { 0xba, 0x7a, 0x00, 0xc0, 0x4f, 0xa0, 0xd2, 0x6b }}; return iid;} virtual nsresult Init(nsIFile *executable) = 0; virtual nsresult InitWithPid(PRUint32 pid) = 0; virtual nsresult Kill(void) = 0; virtual nsresult Run(PRBool blocking, const char **args, PRUint32 count, PRUint32 *pid) = 0; virtual nsresult GetLocation(nsIFile * *aLocation) = 0; virtual nsresult GetPid(PRUint32 *aPid) = 0; virtual nsresult GetProcessName(char * *aProcessName) = 0; virtual nsresult GetProcessSignature(PRUint32 *aProcessSignature) = 0; virtual nsresult GetExitValue(PRInt32 *aExitValue) = 0; }; class nsProcess : public nsIProcess { public: public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: virtual nsresult Init(nsIFile *executable); virtual nsresult InitWithPid(PRUint32 pid); virtual nsresult Kill(void); virtual nsresult Run(PRBool blocking, const char **args, PRUint32 count, PRUint32 *pid); virtual nsresult GetLocation(nsIFile * *aLocation); virtual nsresult GetPid(PRUint32 *aPid); virtual nsresult GetProcessName(char * *aProcessName); virtual nsresult GetProcessSignature(PRUint32 *aProcessSignature); virtual nsresult GetExitValue(PRInt32 *aExitValue); nsProcess(); virtual ~nsProcess(); private: nsCOMPtr mExecutable; PRInt32 mExitValue; nsXPIDLCString mTargetPath; PRProcess *mProcess; }; class nsIAtom; class nsString; class nsINameSpace; class nsIElementFactory; class nsINameSpaceManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = { 0xa6cf90d5, 0x15b3, 0x11d2, {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}; return iid;} virtual nsresult CreateRootNameSpace(nsINameSpace*& aRootNameSpace) = 0; virtual nsresult RegisterNameSpace(const nsAReadableString& aURI, PRInt32& aNameSpaceID) = 0; virtual nsresult GetNameSpaceURI(PRInt32 aNameSpaceID, nsAWritableString& aURI) = 0; virtual nsresult GetNameSpaceID(const nsAReadableString& aURI, PRInt32& aNameSpaceID) = 0; virtual nsresult GetElementFactory(PRInt32 aNameSpaceID, nsIElementFactory **aElementFactory) = 0; }; nsresult NS_NewNameSpaceManager(nsINameSpaceManager** aInstancePtrResult); void NS_NameSpaceManagerShutdown(); class nsIEventQueue; class nsIProxyObjectManager : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0xeea90d43, 0xb059, 0x11d2, { 0x91, 0x5e, 0xc1, 0x2b, 0x69, 0x6c, 0x93, 0x33 }}; return iid;} virtual nsresult GetProxyForObject(nsIEventQueue *destQueue, const nsIID & iid, nsISupports *object, PRInt32 proxyType, void * *result) = 0; virtual nsresult GetProxy(nsIEventQueue *destQueue, const nsIID & cid, nsISupports *aOuter, const nsIID & iid, PRInt32 proxyType, void * *result) = 0; }; struct nsXPTCMiniVariant { union { PRInt8 i8; PRInt16 i16; PRInt32 i32; PRInt64 i64; PRUint8 u8; PRUint16 u16; PRUint32 u32; PRUint64 u64; float f; double d; PRBool b; char c; PRUnichar wc; void* p; } val; }; struct nsXPTCVariant : public nsXPTCMiniVariant { void* ptr; nsXPTType type; PRUint8 flags; enum { PTR_IS_DATA = 0x1, VAL_IS_ALLOCD= 0x2, VAL_IS_IFACE = 0x4, VAL_IS_ARRAY = 0x8, VAL_IS_DOMSTR= 0x10 }; void ClearFlags() {flags = 0;} void SetPtrIsData() {flags |= PTR_IS_DATA;} void SetValIsAllocated() {flags |= VAL_IS_ALLOCD;} void SetValIsInterface() {flags |= VAL_IS_IFACE;} void SetValIsArray() {flags |= VAL_IS_ARRAY;} void SetValIsDOMString() {flags |= VAL_IS_DOMSTR;} PRBool IsPtrData() const {return 0 != (flags & PTR_IS_DATA);} PRBool IsValAllocated() const {return 0 != (flags & VAL_IS_ALLOCD);} PRBool IsValInterface() const {return 0 != (flags & VAL_IS_IFACE);} PRBool IsValArray() const {return 0 != (flags & VAL_IS_ARRAY);} PRBool IsValDOMString() const {return 0 != (flags & VAL_IS_DOMSTR);} void Init(const nsXPTCMiniVariant& mv, const nsXPTType& t, PRUint8 f) { type = t; flags = f; if(f & PTR_IS_DATA) { ptr = mv.val.p; val.p = 0; } else { ptr = 0; switch(t.TagPart()) { case nsXPTType::T_I8: val.i8 = mv.val.i8; break; case nsXPTType::T_I16: val.i16 = mv.val.i16; break; case nsXPTType::T_I32: val.i32 = mv.val.i32; break; case nsXPTType::T_I64: val.i64 = mv.val.i64; break; case nsXPTType::T_U8: val.u8 = mv.val.u8; break; case nsXPTType::T_U16: val.u16 = mv.val.u16; break; case nsXPTType::T_U32: val.u32 = mv.val.u32; break; case nsXPTType::T_U64: val.u64 = mv.val.u64; break; case nsXPTType::T_FLOAT: val.f = mv.val.f; break; case nsXPTType::T_DOUBLE: val.d = mv.val.d; break; case nsXPTType::T_BOOL: val.b = mv.val.b; break; case nsXPTType::T_CHAR: val.c = mv.val.c; break; case nsXPTType::T_WCHAR: val.wc = mv.val.wc; break; case nsXPTType::T_VOID: case nsXPTType::T_IID: case nsXPTType::T_DOMSTRING: case nsXPTType::T_CHAR_STR: case nsXPTType::T_WCHAR_STR: case nsXPTType::T_INTERFACE: case nsXPTType::T_INTERFACE_IS: case nsXPTType::T_ARRAY: case nsXPTType::T_PSTRING_SIZE_IS: case nsXPTType::T_PWSTRING_SIZE_IS: default: val.p = mv.val.p; break; } } } }; class nsXPTCStubBase : public nsISupports { public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsresult Stub3(); virtual nsresult Stub4(); virtual nsresult Stub5(); virtual nsresult Stub6(); virtual nsresult Stub7(); virtual nsresult Stub8(); virtual nsresult Stub9(); virtual nsresult Stub10(); virtual nsresult Stub11(); virtual nsresult Stub12(); virtual nsresult Stub13(); virtual nsresult Stub14(); virtual nsresult Stub15(); virtual nsresult Stub16(); virtual nsresult Stub17(); virtual nsresult Stub18(); virtual nsresult Stub19(); virtual nsresult Stub20(); virtual nsresult Stub21(); virtual nsresult Stub22(); virtual nsresult Stub23(); virtual nsresult Stub24(); virtual nsresult Stub25(); virtual nsresult Stub26(); virtual nsresult Stub27(); virtual nsresult Stub28(); virtual nsresult Stub29(); virtual nsresult Stub30(); virtual nsresult Stub31(); virtual nsresult Stub32(); virtual nsresult Stub33(); virtual nsresult Stub34(); virtual nsresult Stub35(); virtual nsresult Stub36(); virtual nsresult Stub37(); virtual nsresult Stub38(); virtual nsresult Stub39(); virtual nsresult Stub40(); virtual nsresult Stub41(); virtual nsresult Stub42(); virtual nsresult Stub43(); virtual nsresult Stub44(); virtual nsresult Stub45(); virtual nsresult Stub46(); virtual nsresult Stub47(); virtual nsresult Stub48(); virtual nsresult Stub49(); virtual nsresult Stub50(); virtual nsresult Stub51(); virtual nsresult Stub52(); virtual nsresult Stub53(); virtual nsresult Stub54(); virtual nsresult Stub55(); virtual nsresult Stub56(); virtual nsresult Stub57(); virtual nsresult Stub58(); virtual nsresult Stub59(); virtual nsresult Stub60(); virtual nsresult Stub61(); virtual nsresult Stub62(); virtual nsresult Stub63(); virtual nsresult Stub64(); virtual nsresult Stub65(); virtual nsresult Stub66(); virtual nsresult Stub67(); virtual nsresult Stub68(); virtual nsresult Stub69(); virtual nsresult Stub70(); virtual nsresult Stub71(); virtual nsresult Stub72(); virtual nsresult Stub73(); virtual nsresult Stub74(); virtual nsresult Stub75(); virtual nsresult Stub76(); virtual nsresult Stub77(); virtual nsresult Stub78(); virtual nsresult Stub79(); virtual nsresult Stub80(); virtual nsresult Stub81(); virtual nsresult Stub82(); virtual nsresult Stub83(); virtual nsresult Stub84(); virtual nsresult Stub85(); virtual nsresult Stub86(); virtual nsresult Stub87(); virtual nsresult Stub88(); virtual nsresult Stub89(); virtual nsresult Stub90(); virtual nsresult Stub91(); virtual nsresult Stub92(); virtual nsresult Stub93(); virtual nsresult Stub94(); virtual nsresult Stub95(); virtual nsresult Stub96(); virtual nsresult Stub97(); virtual nsresult Stub98(); virtual nsresult Stub99(); virtual nsresult Stub100(); virtual nsresult Stub101(); virtual nsresult Stub102(); virtual nsresult Stub103(); virtual nsresult Stub104(); virtual nsresult Stub105(); virtual nsresult Stub106(); virtual nsresult Stub107(); virtual nsresult Stub108(); virtual nsresult Stub109(); virtual nsresult Stub110(); virtual nsresult Stub111(); virtual nsresult Stub112(); virtual nsresult Stub113(); virtual nsresult Stub114(); virtual nsresult Stub115(); virtual nsresult Stub116(); virtual nsresult Stub117(); virtual nsresult Stub118(); virtual nsresult Stub119(); virtual nsresult Stub120(); virtual nsresult Stub121(); virtual nsresult Stub122(); virtual nsresult Stub123(); virtual nsresult Stub124(); virtual nsresult Stub125(); virtual nsresult Stub126(); virtual nsresult Stub127(); virtual nsresult Stub128(); virtual nsresult Stub129(); virtual nsresult Stub130(); virtual nsresult Stub131(); virtual nsresult Stub132(); virtual nsresult Stub133(); virtual nsresult Stub134(); virtual nsresult Stub135(); virtual nsresult Stub136(); virtual nsresult Stub137(); virtual nsresult Stub138(); virtual nsresult Stub139(); virtual nsresult Stub140(); virtual nsresult Stub141(); virtual nsresult Stub142(); virtual nsresult Stub143(); virtual nsresult Stub144(); virtual nsresult Stub145(); virtual nsresult Stub146(); virtual nsresult Stub147(); virtual nsresult Stub148(); virtual nsresult Stub149(); virtual nsresult Stub150(); virtual nsresult Stub151(); virtual nsresult Stub152(); virtual nsresult Stub153(); virtual nsresult Stub154(); virtual nsresult Stub155(); virtual nsresult Stub156(); virtual nsresult Stub157(); virtual nsresult Stub158(); virtual nsresult Stub159(); virtual nsresult Stub160(); virtual nsresult Stub161(); virtual nsresult Stub162(); virtual nsresult Stub163(); virtual nsresult Stub164(); virtual nsresult Stub165(); virtual nsresult Stub166(); virtual nsresult Stub167(); virtual nsresult Stub168(); virtual nsresult Stub169(); virtual nsresult Stub170(); virtual nsresult Stub171(); virtual nsresult Stub172(); virtual nsresult Stub173(); virtual nsresult Stub174(); virtual nsresult Stub175(); virtual nsresult Stub176(); virtual nsresult Stub177(); virtual nsresult Stub178(); virtual nsresult Stub179(); virtual nsresult Stub180(); virtual nsresult Stub181(); virtual nsresult Stub182(); virtual nsresult Stub183(); virtual nsresult Stub184(); virtual nsresult Stub185(); virtual nsresult Stub186(); virtual nsresult Stub187(); virtual nsresult Stub188(); virtual nsresult Stub189(); virtual nsresult Stub190(); virtual nsresult Stub191(); virtual nsresult Stub192(); virtual nsresult Stub193(); virtual nsresult Stub194(); virtual nsresult Stub195(); virtual nsresult Stub196(); virtual nsresult Stub197(); virtual nsresult Stub198(); virtual nsresult Stub199(); virtual nsresult Stub200(); virtual nsresult Stub201(); virtual nsresult Stub202(); virtual nsresult Stub203(); virtual nsresult Stub204(); virtual nsresult Stub205(); virtual nsresult Stub206(); virtual nsresult Stub207(); virtual nsresult Stub208(); virtual nsresult Stub209(); virtual nsresult Stub210(); virtual nsresult Stub211(); virtual nsresult Stub212(); virtual nsresult Stub213(); virtual nsresult Stub214(); virtual nsresult Stub215(); virtual nsresult Stub216(); virtual nsresult Stub217(); virtual nsresult Stub218(); virtual nsresult Stub219(); virtual nsresult Stub220(); virtual nsresult Stub221(); virtual nsresult Stub222(); virtual nsresult Stub223(); virtual nsresult Stub224(); virtual nsresult Stub225(); virtual nsresult Stub226(); virtual nsresult Stub227(); virtual nsresult Stub228(); virtual nsresult Stub229(); virtual nsresult Stub230(); virtual nsresult Stub231(); virtual nsresult Stub232(); virtual nsresult Stub233(); virtual nsresult Stub234(); virtual nsresult Stub235(); virtual nsresult Stub236(); virtual nsresult Stub237(); virtual nsresult Stub238(); virtual nsresult Stub239(); virtual nsresult Stub240(); virtual nsresult Stub241(); virtual nsresult Stub242(); virtual nsresult Stub243(); virtual nsresult Stub244(); virtual nsresult Stub245(); virtual nsresult Stub246(); virtual nsresult Stub247(); virtual nsresult Stub248(); virtual nsresult Stub249(); virtual nsresult Sentinel0(); virtual nsresult Sentinel1(); virtual nsresult Sentinel2(); virtual nsresult Sentinel3(); virtual nsresult Sentinel4(); virtual nsresult GetInterfaceInfo(nsIInterfaceInfo** info) = 0; virtual nsresult CallMethod(PRUint16 methodIndex, const nsXPTMethodInfo* info, nsXPTCMiniVariant* params) = 0; }; extern "C" { nsresult XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex, PRUint32 paramCount, nsXPTCVariant* params); extern void xptc_dummy(); extern void xptc_dummy2(); } class nsProxyObjectCallInfo; class nsProxyObject : public nsISupports { public: public: virtual nsresult QueryInterface(const nsIID& aIID, void** aInstancePtr); virtual nsrefcnt AddRef(void); virtual nsrefcnt Release(void); protected: nsrefcnt mRefCnt; void* _mOwningThread; public: static const nsIID& GetIID() {static const nsIID iid = { 0x00000000, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }; return iid;} nsProxyObject(); nsProxyObject(nsIEventQueue *destQueue, PRInt32 proxyType, nsISupports *realObject); nsProxyObject(nsIEventQueue *destQueue, PRInt32 proxyType, const nsCID &aClass, nsISupports *aDelegate, const nsIID &aIID); virtual ~nsProxyObject(); nsresult Post( PRUint32 methodIndex, nsXPTMethodInfo * info, nsXPTCMiniVariant * params, nsIInterfaceInfo * interfaceInfo); nsresult PostAndWait(nsProxyObjectCallInfo *proxyInfo); nsISupports* GetRealObject() const; nsIEventQueue* GetQueue() const; PRInt32 GetProxyType() const { return mProxyType; } friend class nsProxyEventObject; private: PRInt32 mProxyType; nsCOMPtr mDestQueue; nsCOMPtr mRealObject; nsCOMPtr mEventQService; nsresult convertMiniVariantToVariant(nsXPTMethodInfo * methodInfo, nsXPTCMiniVariant * params, nsXPTCVariant **fullParam, uint8 *paramCount); }; class nsProxyObjectCallInfo { public: nsProxyObjectCallInfo(nsProxyObject* owner, nsXPTMethodInfo *methodInfo, PRUint32 methodIndex, nsXPTCVariant* parameterList, PRUint32 parameterCount, PLEvent *event); virtual ~nsProxyObjectCallInfo(); PRUint32 GetMethodIndex() const { return mMethodIndex; } nsXPTCVariant* GetParameterList() const { return mParameterList; } PRUint32 GetParameterCount() const { return mParameterCount; } PLEvent* GetPLEvent() const { return mEvent; } nsresult GetResult() const { return mResult; } nsProxyObject* GetProxyObject() const { return mOwner; } PRBool GetCompleted(); void SetCompleted(); void PostCompleted(); void SetResult(nsresult rv) {mResult = rv; } nsIEventQueue* GetCallersQueue(); void SetCallersQueue(nsIEventQueue* queue); private: nsresult mResult; nsXPTMethodInfo *mMethodInfo; PRUint32 mMethodIndex; nsXPTCVariant *mParameterList; PRUint32 mParameterCount; PLEvent *mEvent; PRInt32 mCompleted; nsCOMPtr mCallersEventQ; nsCOMPtr mOwner; void RefCountInInterfacePointers(PRBool addRef); void CopyStrings(PRBool copy); }; extern nsresult NS_GetProxyForObject(nsIEventQueue *destQueue, const nsIID& aIID, nsISupports* aObj, PRInt32 proxyType, void** aProxyObject); class nsProxiedService { public: nsProxiedService(const nsCID &aClass, const nsIID &aIID, nsIEventQueue* pIProxyQueue, PRBool always, nsresult*rv) { static const nsCID kProxyObjectManagerCID = { 0xeea90d41, 0xb059, 0x11d2, {0x91, 0x5e, 0xc1, 0x2b, 0x69, 0x6c, 0x93, 0x33}}; *rv = nsServiceManager::GetService(aClass, aIID, getter_AddRefs(mService)); if (((*rv) & 0x80000000)) return; nsCOMPtr pIProxyObjectManager = do_GetService(kProxyObjectManagerCID, rv); if (((*rv) & 0x80000000)) return; PRInt32 proxyType = 0x0001; if (always) proxyType |= 0x0004; *rv = pIProxyObjectManager->GetProxyForObject(pIProxyQueue, aIID, mService, proxyType, getter_AddRefs(mProxiedService)); } ~nsProxiedService() { } nsISupports* operator->() const { if (!(mProxiedService != 0)) nsDebug::PreCondition("Your code should test the error result from the constructor.", "mProxiedService != 0", "../../dist/include/xpcom/nsProxiedService.h", 130); return mProxiedService; } PRBool operator==(const nsISupports* other) { return ((mProxiedService == other) || (mService == other)); } operator nsISupports*() const { return mProxiedService; } protected: nsCOMPtr mProxiedService; nsCOMPtr mService; }; class nsIURIContentListener; class nsIURI; class nsILoadGroup; class nsIDocumentLoader; class nsIProgressEventSink; class nsIChannel; class nsIRequest; class nsIStreamListener; class nsIInputStream; class nsIURILoader : public nsISupports { public: static const nsIID& GetIID() {static const nsIID iid = {0x40aecb53, 0x8b65, 0x11d3, { 0x98, 0x9d, 0x00, 0x10, 0x83, 0x01, 0x0e, 0x9b }}; return iid;} virtual nsresult RegisterContentListener(nsIURIContentListener *aContentListener) = 0; virtual nsresult UnRegisterContentListener(nsIURIContentListener *aContentListener) = 0; virtual nsresult OpenURI(nsIChannel *aChannel, PRBool aIsContentPreferred, nsISupports *aWindowContext) = 0; virtual nsresult OpenURIVia(nsIChannel *aChannel, PRBool aIsContentPreferred, nsISupports *aWindowContext, PRUint32 adapterBinding) = 0; virtual nsresult Stop(nsISupports *aLoadCookie) = 0; virtual nsresult GetLoadGroupForContext(nsISupports *aWindowContext, nsILoadGroup **_retval) = 0; virtual nsresult GetDocumentLoaderForContext(nsISupports *aWindowContext, nsIDocumentLoader **_retval) = 0; virtual nsresult DispatchContent(const char *aContentType, PRBool aIsContentPreferred, nsIRequest *aRequest, nsISupports *aCtxt, nsIURIContentListener *aContentListener, nsISupports *aSrcWindowContext, char **aDesiredContentType, nsIURIContentListener **aTargetListener, PRBool *abortDispatch) = 0; }; extern "C" void RunChromeInstallOnThread(void *data); static const nsCID kComponentManagerCID = { 0x91775d60, 0xd5dc, 0x11d2, {0x92, 0xfb, 0x00, 0xe0, 0x98, 0x05, 0x57, 0x0f} }; static const nsCID kCScriptNameSetRegistryCID = { 0x45f27d10, 0x987b, 0x11d2, {0xbd, 0x40, 0x00, 0x10, 0x5a, 0xa4, 0x5e, 0x89} }; static const nsCID kInstallTrigger_CID = { 0x18c2f98d, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }; static const nsCID kInstallVersion_CID = { 0x18c2f98f, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }; static const nsCID kChromeRegistryCID = { 0xd8c7d8a2, 0xe84c, 0x11d2, { 0xbf, 0x87, 0x0, 0x10, 0x5a, 0x1b, 0x6, 0x27 } }; static const nsCID knsRegistryCID = { 0xbe761f00, 0xa3b0, 0x11d2, {0x99, 0x6c, 0x00, 0x80, 0xc7, 0xcb, 0x10, 0x81} }; static const nsCID kIProcessCID = {0x7b4eeb20, 0xd781, 0x11d4, {0x8A, 0x83, 0x00, 0x10, 0xa4, 0xe0, 0xc9, 0xca}}; nsSoftwareUpdate* nsSoftwareUpdate::mInstance = 0; nsCOMPtr nsSoftwareUpdate::mProgramDir = 0; char* nsSoftwareUpdate::mLogName = 0; PRBool nsSoftwareUpdate::mNeedCleanup = 0; nsSoftwareUpdate * nsSoftwareUpdate::GetInstance() { if (mInstance == 0) mInstance = new nsSoftwareUpdate(); ((0 != (mInstance)) ? ns_if_addref(mInstance) : 0); return mInstance; } nsSoftwareUpdate::nsSoftwareUpdate() : mInstalling(0), mMasterListener(0), mReg(0) { (mRefCnt = 0, (_mOwningThread = NS_CurrentThread())); mLock = PR_NewLock(); NR_StartupRegistry(); nsresult rv; nsCOMPtr directoryService = do_GetService("@mozilla.org/file/directory_service;1", &rv); if(!directoryService) return; nsCOMPtr dir; directoryService->Get("XCurProcD", nsCOMTypeInfo::GetIID(), getter_AddRefs(dir)); if (dir) { char* nativePath; dir->GetPath(&nativePath); VR_SetRegDirectory( nativePath ); if (nativePath) nsMemory::Free(nativePath); } nsCOMPtr observerService = do_GetService("@mozilla.org/observer-service;1", &rv); if ((!((rv) & 0x80000000))) observerService->AddObserver(this, "xpcom-shutdown", 0); } nsSoftwareUpdate::~nsSoftwareUpdate() { PR_Lock(mLock); nsInstallInfo* element; for (PRInt32 i=0; i < mJarInstallQueue.Count(); i++) { element = (nsInstallInfo*)mJarInstallQueue.ElementAt(i); delete element; } mJarInstallQueue.Clear(); PR_Unlock(mLock); PR_DestroyLock(mLock); NR_ShutdownRegistry(); do { if (mMasterListener) { (mMasterListener)->Release(); (mMasterListener) = 0; } } while (0); mInstance = 0; if (mLogName) { PR_Free(mLogName); (mLogName) = __null; }; } nsrefcnt nsSoftwareUpdate::AddRef(void) { if (!(PRInt32(mRefCnt) >= 0)) nsDebug::PreCondition("illegal refcnt", "PRInt32(mRefCnt) >= 0", "nsSoftwareUpdate.cpp", 185); nsrefcnt count; count = PR_AtomicIncrement((PRInt32*)&mRefCnt); nsTraceRefcnt::LogAddRef((this), (count), ("nsSoftwareUpdate"), (PRUint32) (sizeof(*this))); return count; } nsrefcnt nsSoftwareUpdate::Release(void) { nsrefcnt count; if (!(0 != mRefCnt)) nsDebug::PreCondition("dup release", "0 != mRefCnt", "nsSoftwareUpdate.cpp", 185); count = PR_AtomicDecrement((PRInt32 *)&mRefCnt); nsTraceRefcnt::LogRelease((this), (count), ("nsSoftwareUpdate")); if (0 == count) { mRefCnt = 1; do { ; delete (this); } while (0); return 0; } return count; } nsresult nsSoftwareUpdate::QueryInterface(const nsIID& aIID, void** aInstancePtr) { if (!(aInstancePtr)) nsDebug::Assertion("QueryInterface requires a non-NULL destination!", "aInstancePtr", "nsSoftwareUpdate.cpp", 185); if ( !aInstancePtr ) return ((nsresult) 0x80004003L); nsIS! upports* foundInterface; if ( aIID.Equals(nsCOMTypeInfo::GetIID()) ) foundInterface = static_cast< nsISoftwareUpdate* >(this); else if ( aIID.Equals(nsCOMTypeInfo::GetIID()) ) foundInterface = static_cast< nsPIXPIStubHook* >(this); else if ( aIID.Equals(nsCOMTypeInfo::GetIID()) ) foundInterface = static_cast< nsIObserver* >(this); else if ( aIID.Equals(nsCOMTypeInfo::GetIID()) ) foundInterface = static_cast< nsISupports* >(static_cast< nsISoftwareUpdate* >(this)); else foundInterface = 0; nsresult status; if ( !foundInterface ) status = ((nsresult) 0x80004002L); else { (foundInterface)->AddRef(); status = 0; } *aInstancePtr = foundInterface; return status; }; void nsSoftwareUpdate::Shutdown() { if (mNeedCleanup) { nsresult rv; nsCOMPtr pathToCleanupUtility; nsCOMPtr directoryService = do_GetService("@mozilla.org/file/directory_service;1", &rv); directoryService->Get("CurProcD", nsCOMTypeInfo::GetIID(), getter_AddRefs(pathToCleanupUtility)); pathToCleanupUtility->Append("xpicleanup"); nsCOMPtr cleanupProcess = do_CreateInstance(kIProcessCID); rv = cleanupProcess->Init(pathToCleanupUtility); if ((!((rv) & 0x80000000))) { rv = cleanupProcess->Run(0, 0, 0, 0); } } } nsresult nsSoftwareUpdate::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData) { if (!nsCRT::strcmp(aTopic, "xpcom-shutdown")) Shutdown(); return 0; } nsresult nsSoftwareUpdate::RegisterListener(nsIXPIListener *aListener) { if (!mMasterListener) CreateMasterListener(); if (!mMasterListener) return ((nsresult) 0x80004005L); mMasterListener->RegisterListener(aListener); return 0; } nsresult nsSoftwareUpdate::GetMasterListener(nsIXPIListener **aListener) { if (!(aListener)) nsDebug::Assertion("getter has invalid return pointer", "aListener", "nsSoftwareUpdate.cpp", 248); if (!aListener) return ((nsresult) 0x80004003L); if (!mMasterListener) CreateMasterListener(); if (!mMasterListener) return ((nsresult) 0x80004005L); (mMasterListener)->AddRef(); *aListener = mMasterListener; return 0; } nsresult nsSoftwareUpdate::SetActiveListener(nsIXPIListener *aListener) { if (!mMasterListener) CreateMasterListener(); if (!mMasterListener) return ((nsresult) 0x80004005L); mMasterListener->SetActiveListener (aListener); return 0; } void nsSoftwareUpdate::CreateMasterListener() { mMasterListener = new nsTopProgressListener; if (mMasterListener) { (mMasterListener)->AddRef(); nsLoggingProgressListener *logger = new nsLoggingProgressListener(); mMasterListener->RegisterListener(logger); } } nsresult nsSoftwareUpdate::InstallJar( nsIFile* aLocalFile, const PRUnichar* aURL, const PRUnichar* aArguments, nsIDOMWindowInternal* aParentWindow, PRUint32 flags, nsIXPIListener* aListener) { if ( !aLocalFile ) return ((nsresult) 0x80004003L); nsresult rv; nsIChromeRegistry* chromeReg = 0; nsProxiedService _servtmpReg(kChromeRegistryCID, nsCOMTypeInfo::GetIID(), ((nsIEventQueue*)1), 1, &rv); nsIChromeRegistry* tmpReg = (nsIChromeRegistry*)(nsISupports*)_servtmpReg;; if ((!((rv) & 0x80000000))) chromeReg = tmpReg; nsInstallInfo *info = new nsInstallInfo( 0, aLocalFile, aURL, aArguments, flags, aListener, aParentWindow, chromeReg ); if (!info) return ((nsresult) 0x8007000eL); PR_Lock(mLock); mJarInstallQueue.AppendElement( info ); PR_Unlock(mLock); RunNextInstall(); return 0; } nsresult nsSoftwareUpdate::InstallChrome( PRUint32 aType, nsIFile* aFile, const PRUnichar* URL, const PRUnichar* aName, PRBool aSelect, nsIXPIListener* aListener) { nsresult rv; nsProxiedService _servchromeReg(kChromeRegistryCID, nsCOMTypeInfo::GetIID(), ((nsIEventQueue*)1), 1, &rv); nsIChromeRegistry* chromeReg = (nsIChromeRegistry*)(nsISupports*)_servchromeReg;; if (((rv) & 0x80000000)) return rv; nsInstallInfo *info = new nsInstallInfo( aType, aFile, URL, aName, (PRUint32)aSelect, aListener, 0, chromeReg); if (!info) return ((nsresult) 0x8007000eL); PR_CreateThread(PR_USER_THREAD, RunChromeInstallOnThread, (void*)info, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0); return 0; } nsresult nsSoftwareUpdate::InstallJarCallBack() { PR_Lock(mLock); if (mJarInstallQueue.Count() != 0) { nsInstallInfo *nextInstall = (nsInstallInfo*)mJarInstallQueue.ElementAt(0); if (nextInstall != 0) delete nextInstall; mJarInstallQueue.RemoveElementAt(0); } mInstalling = 0; PR_Unlock(mLock); return RunNextInstall(); } nsresult nsSoftwareUpdate::StartupTasks( PRBool *needAutoreg ) { PRBool autoReg = 0; RKEY xpiRoot; REGERR err; *needAutoreg = 1; if ( (0) == NR_RegOpen("", &mReg) ) { PerformScheduledTasks(mReg); err = NR_RegGetKey( mReg, (0x02), "software/mozilla/xpinstall", &xpiRoot); if ( err == (0) ) { char buf[8]; err = NR_RegGetEntryString( mReg, xpiRoot, "Autoreg", buf, sizeof(buf) ); if ( err == (0) && !strcmp( buf, "yes" ) ) autoReg = 1; } } nsresult rv; PRInt32 buildID = -1; nsRegistryKey idKey = 0; nsCOMPtr reg = do_GetService(knsRegistryCID,&rv); if ((!((rv) & 0x80000000))) { rv = reg->OpenWellKnownRegistry(nsIRegistry::ApplicationComponentRegistry); if ((!((rv) & 0x80000000))) { rv = reg->GetSubtree(nsIRegistry::Common,"software/mozilla/XPCOM",&idKey); if ((!((rv) & 0x80000000))) { rv = reg->GetInt( idKey, "Autoreg", &buildID ); } } } if ( autoReg || ((rv) & 0x80000000) || buildID != 0000000000 ) { rv = nsComponentManager::AutoRegister(nsIComponentManagerObsolete::NS_Startup,0); if ((!((rv) & 0x80000000))) { *needAutoreg = 0; if ( autoReg ) NR_RegSetEntryString( mReg, xpiRoot, "Autoreg", "no" ); if ( buildID != 0000000000 && idKey != 0 ) reg->SetInt( idKey, "Autoreg", 0000000000 ); } } else { *needAutoreg = 0; *needAutoreg = 1; } return rv; } nsresult nsSoftwareUpdate::RunNextInstall() { nsresult rv = 0; nsInstallInfo* info = 0; PR_Lock(mLock); if (!mMasterListener) CreateMasterListener(); if (!mInstalling) { if ( mJarInstallQueue.Count() > 0 ) { info = (nsInstallInfo*)mJarInstallQueue.ElementAt(0); if ( info ) mInstalling = 1; else { nsDebug::Error("leaks remaining nsInstallInfos, please file bug!", "nsSoftwareUpdate.cpp", 491); rv = ((nsresult) 0x80004003L); VR_Close(); } } else { VR_Close(); } } PR_Unlock(mLock); if (info) RunInstall( info ); return rv; } nsresult nsSoftwareUpdate::StubInitialize(nsIFile *aDir, const char* logName) { if ( !aDir ) return ((nsresult) 0x80004003L); nsresult rv = aDir->Clone(getter_AddRefs(mProgramDir)); nsXPIDLCString tempPath; rv = aDir->GetPath(getter_Copies(tempPath)); if ((!((rv) & 0x80000000))) VR_SetRegDirectory( tempPath ); if (logName) { mLogName = PL_strdup(logName); if (!mLogName) return ((nsresult) 0x8007000eL); } return rv; } nsSoftwareUpdateNameSet::nsSoftwareUpdateNameSet() { (mRefCnt = 0, (_mOwningThread = NS_CurrentThread())); } nsSoftwareUpdateNameSet::~nsSoftwareUpdateNameSet() { } nsrefcnt nsSoftwareUpdateNameSet::AddRef(void) { if (!(PRInt32(mRefCnt) >= 0)) nsDebug::PreCondition("illegal refcnt", "PRInt32(mRefCnt) >= 0", "nsSoftwareUpdate.cpp", 552); NS_CheckThreadSafe(_mOwningThread, "nsSoftwareUpdateNameSet" " not thread-safe"); ++mRefCnt; nsTraceRefcnt::LogAddRef((this), (mRefCnt), ("nsSoftwareUpdateNameSet"), (PRUint32) (sizeof(*this))); return mRefCnt; } nsrefcnt nsSoftwareUpdateNameSet::Release(void) { if (!(0 != mRefCnt)) nsDebug::PreCondition("dup release", "0 != mRefCnt", "nsSoftwareUpdate.cpp", 552); NS_CheckThreadSafe(_mOwningThread, "nsSoftwareUpdateNameSet" " not thread-safe"); --mRefCnt; nsTraceRefcnt::LogRelease((this), (mRefCnt), ("nsSoftwareUpdateNameSet")); if (mRefCnt == 0) { mRefCnt = 1; do { ; delete (this); } while (0); return 0; } return mRefCnt; } nsresult nsSoftwareUpdateNameSet::QueryInterface(const nsIID& aIID, void** aInstancePtr) { if (!(aInstancePtr)) nsDebug::Assertion("QueryInterface requires a non-NULL destination!", "a! InstancePtr", "nsSoftwareUpdate.cpp", 552); if ( !aInstancePtr ) return ((nsresult) 0x80004003L); nsISupports* foundInterface; if ( aIID.Equals(nsCOMTypeInfo::GetIID()) ) foundInterface = static_cast< nsIScriptExternalNameSet* >(this); else if ( aIID.Equals(nsCOMTypeInfo::GetIID()) ) foundInterface = static_cast< nsISupports* >(static_cast< nsIScriptExternalNameSet* >(this)); else foundInterface = 0; nsresult status; if ( !foundInterface ) status = ((nsresult) 0x80004002L); else { (foundInterface)->AddRef(); status = 0; } *aInstancePtr = foundInterface; return status; } nsresult nsSoftwareUpdateNameSet::InitializeNameSet(nsIScriptContext* aScriptContext) { nsresult result = 0; result = NS_InitInstallVersionClass(aScriptContext, 0); if (((result) & 0x80000000)) return result; result = NS_InitInstallTriggerGlobalClass(aScriptContext, 0); return result; } static nsresult nsSoftwareUpdateConstructor(nsISupports *aOuter, const nsIID& aIID, void **aResult) { nsresult rv; nsSoftwareUpdate * inst; *aResult = __null; if (__null != aOuter) { rv = ((nsresult) 0x80040110L); return rv; } inst = nsSoftwareUpdate::GetInstance(); if (__null == inst) { rv = ((nsresult) 0x8007000eL); return rv; } rv = inst->QueryInterface(aIID, aResult); do { (inst)->Release(); (inst) = 0; } while (0); return rv; }; static nsresult nsInstallTriggerConstructor(nsISupports *aOuter, const nsIID& aIID, void **aResult) { nsresult rv; nsInstallTrigger * inst; *aResult = __null; if (__null != aOuter) { rv = ((nsresult) 0x80040110L); return rv; } do { inst = new nsInstallTrigger(); ; } while (0); if (__null == inst) { rv = ((nsresult) 0x8007000eL); return rv; } (inst)->AddRef(); rv = inst->QueryInterface(aIID, aResult); do { (inst)->Release(); (inst) = 0; } while (0); return rv; }; static nsresult nsInstallVersionConstructor(nsISupports *aOuter, const nsIID& aIID, void **aResult) { nsresult rv; nsInstallVersion * inst; *aResult = __null; if (__null != aOuter) { rv = ((nsresult) 0x80040110L); return rv; } do { inst = new nsInstallVersion(); ; } while (0); if (__null == inst) { rv = ((nsresult) 0x8007000eL); return rv; } (inst)->AddRef(); rv = inst->QueryInterface(aIID, aResult); do { (inst)->Release(); (inst) = 0; } while (0); return rv; }; static nsresult nsSoftwareUpdateNameSetConstructor(nsISupports *aOuter, const nsIID& aIID, void **aResult) { nsresult rv; nsSoftwareUpdateNameSet * inst; *aResult = __null; if (__null != aOuter) { rv = ((nsresult) 0x80040110L); return rv; } do { inst = new nsSoftwareUpdateNameSet(); ; } while (0); if (__null == inst) { rv = ((nsresult) 0x8007000eL); return rv; } (inst)->AddRef(); rv = inst->QueryInterface(aIID, aResult); do { (inst)->Release(); (inst) = 0; } while (0); return rv; }; static nsresult RegisterSoftwareUpdate( nsIComponentManager *aCompMgr, nsIFile *aPath, const char *registryLocation, const char *componentType, const nsModuleComponentInfo *info) { nsresult rv = 0; nsCOMPtr catman = do_GetService("@mozilla.org/categorymanager;1", &rv); do { if((!((!((rv) & 0x80000000))) ? nsDebug::WarnIfFalse("NS_ENSURE_TRUE(" "NS_SUCCEEDED(rv)" ") failed", "(!((rv) & 0x80000000))", "nsSoftwareUpdate.cpp", 600) : 0)) return rv; } while (0); nsXPIDLCString previous; rv = catman->AddCategoryEntry("JavaScript global constructor", "InstallVersion", "@mozilla.org/xpinstall/installversion;1", 1, 1, getter_Copies(previous)); do { if((!((!((rv) & 0x80000000))) ? nsDebug::WarnIfFalse("NS_ENSURE_TRUE(" "NS_SUCCEEDED(rv)" ") failed", "(!((rv) & 0x80000000))", "nsSoftwareUpdate.cpp", 607) : 0)) return rv; } while (0); rv = catman->AddCategoryEntry("JavaScript global property", "InstallTrigger", "@mozilla.org/xpinstall/installtrigger;1", 1, 1, getter_Copies(previous)); do { if((!((!((rv) & 0x80000000))) ? nsDebug::WarnIfFalse("NS_ENSURE_TRUE(" "NS_SUCCEEDED(rv)" ") failed", "(!((rv) & 0x80000000))", "nsSoftwareUpdate.cpp", 613) : 0)) return rv; } while (0); return 0; } static nsModuleComponentInfo components[] = { { "SoftwareUpdate Component", { 0x18c2f989, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }, "@mozilla.org/xpinstall;1", nsSoftwareUpdateConstructor, RegisterSoftwareUpdate }, { "InstallTrigger Component", { 0x18c2f98d, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }, "@mozilla.org/xpinstall/installtrigger;1", nsInstallTriggerConstructor }, { "InstallVersion Component", { 0x18c2f98f, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }, "@mozilla.org/xpinstall/installversion;1", nsInstallVersionConstructor }, { "XPInstall Content Handler", { 0x18c2f98d, 0xb09f, 0x11d2, {0xbc, 0xde, 0x00, 0x80, 0x5f, 0x0e, 0x13, 0x53} }, "@mozilla.org/uriloader/content-handler;1" "?type=""application/x-xpinstall", nsInstallTriggerConstructor }, { "Software update nameset", { 0xcde48010, 0x9494, 0x4a73, { 0x96, 0x9a, 0x26, 0x33, 0x50, 0x0, 0x70, 0xde }}, "@mozilla.org/xpinstall/softwareupdatenameset;1", nsSoftwareUpdateNameSetConstructor } }; nsModuleInfo gModuleInfo = { 0x00010000UL, ("nsSoftwareUpdate"), (components), (sizeof(components) / sizeof(components[0])), (0), (0) }; extern "C" nsresult NSGetModule(nsIComponentManager *servMgr, nsIFile* location, nsIModule** result) { return NS_NewGenericModule2(&(gModuleInfo), result); } >Fix: >Release-Note: >Audit-Trail: >Unformatted: