public inbox for gcc-prs@sourceware.org
help / color / mirror / Atom feed
* Re: c++/5602: g++3.0.3 internal compiler error emit_move_insn_1, at expr.c:2975
@ 2002-11-05 8:33 bangerth
0 siblings, 0 replies; 2+ messages in thread
From: bangerth @ 2002-11-05 8:33 UTC (permalink / raw)
To: gcc-bugs, gcc-prs, mathew, nobody
Synopsis: g++3.0.3 internal compiler error emit_move_insn_1, at expr.c:2975
State-Changed-From-To: open->closed
State-Changed-By: bangerth
State-Changed-When: Tue Nov 5 08:32:58 2002
State-Changed-Why:
I cannot reproduce this with current compilers.
Next time please use the file attachement button, rather
than pasting 12000 lines of code.
http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=5602
^ permalink raw reply [flat|nested] 2+ messages in thread
* c++/5602: g++3.0.3 internal compiler error emit_move_insn_1, at expr.c:2975
@ 2002-02-05 19:56 Mathew Yeates
0 siblings, 0 replies; 2+ messages in thread
From: Mathew Yeates @ 2002-02-05 19:56 UTC (permalink / raw)
To: gcc-gnats
>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 <class T>
inline
nsrefcnt
ns_if_addref( T expr )
{
return expr ? expr->AddRef() : 0;
}
}
extern "C++" {
class nsISupports;
template <class T>
struct nsCOMTypeInfo
{
static const nsIID& GetIID() { return T::GetIID(); }
};
template <>
struct nsCOMTypeInfo<nsISupports>
{
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 <class T, class DestinationType>
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<DestinationType>::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 T>
class nsDerivedSafe : public T
{
private:
using T::AddRef;
using T::Release;
void operator delete( void*, size_t );
nsDerivedSafe<T>& operator=( const T& );
};
template <class T>
struct already_AddRefed
{
already_AddRefed( T* aRawPtr )
: mRawPtr(aRawPtr)
{
}
T* get() const { return mRawPtr; }
T* mRawPtr;
};
template <class T>
inline
const already_AddRefed<T>
getter_AddRefs( T* aRawPtr )
{
return already_AddRefed<T>(aRawPtr);
}
template <class T>
inline
const already_AddRefed<T>
getter_AddRefs( const already_AddRefed<T>& aAlreadyAddRefedPtr )
{
return aAlreadyAddRefedPtr;
}
template <class T>
inline
const already_AddRefed<T>
dont_AddRef( T* aRawPtr )
{
return already_AddRefed<T>(aRawPtr);
}
template <class T>
inline
const already_AddRefed<T>
dont_AddRef( const already_AddRefed<T> aAlreadyAddRefedPtr )
{
return aAlreadyAddRefedPtr;
}
template <class T>
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 <class T>
inline
void
do_QueryInterface( already_AddRefed<T>& )
{
}
template <class T>
inline
void
do_QueryInterface( already_AddRefed<T>&, 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 T>
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<T> 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<T>& 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<T>& 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<T>::GetIID());
Assert_NoQueryNeeded();;
}
nsCOMPtr( const nsQueryInterface& helper )
: mRawPtr(0)
{
if ((0)) nsTraceRefcnt::LogAddCOMPtr((this),static_cast< nsISupports* >(0));
assign_from_helper(helper, nsCOMTypeInfo<T>::GetIID());
}
nsCOMPtr<T>&
operator=( const nsCOMPtr<T>& rhs )
{
assign_with_AddRef(rhs.mRawPtr);
return *this;
}
nsCOMPtr<T>&
operator=( T* rhs )
{
assign_with_AddRef(rhs);
Assert_NoQueryNeeded();;
return *this;
}
nsCOMPtr<T>&
operator=( const already_AddRefed<T>& rhs )
{
assign_assuming_AddRef(rhs.mRawPtr);
Assert_NoQueryNeeded();;
return *this;
}
nsCOMPtr<T>&
operator=( const nsCOMPtr_helper& rhs )
{
assign_from_helper(rhs, nsCOMTypeInfo<T>::GetIID());
Assert_NoQueryNeeded();;
return *this;
}
nsCOMPtr<T>&
operator=( const nsQueryInterface& rhs )
{
assign_from_helper(rhs, nsCOMTypeInfo<T>::GetIID());
return *this;
}
nsDerivedSafe<T>*
get() const
{
return reinterpret_cast< nsDerivedSafe<T>* >(mRawPtr);
}
operator nsDerivedSafe<T>*() const
{
return get();
}
nsDerivedSafe<T>*
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<T>*
get_address()
{
return this;
}
const nsCOMPtr<T>*
get_address() const
{
return this;
}
private:
const nsCOMPtr<T>*
operator&() const
{
return this;
}
nsCOMPtr<T>*
operator&()
{
return this;
}
public:
nsDerivedSafe<T>&
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<nsISupports>
: 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<nsISupports>& 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<nsISupports>& 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<nsISupports>::GetIID());
}
nsCOMPtr<nsISupports>&
operator=( const nsCOMPtr<nsISupports>& rhs )
{
assign_with_AddRef(rhs.mRawPtr);
return *this;
}
nsCOMPtr<nsISupports>&
operator=( nsISupports* rhs )
{
assign_with_AddRef(rhs);
return *this;
}
nsCOMPtr<nsISupports>&
operator=( const already_AddRefed<nsISupports>& rhs )
{
assign_assuming_AddRef(rhs.mRawPtr);
return *this;
}
nsCOMPtr<nsISupports>&
operator=( const nsCOMPtr_helper& rhs )
{
assign_from_helper(rhs, nsCOMTypeInfo<nsISupports>::GetIID());
return *this;
}
nsDerivedSafe<nsISupports>*
get() const
{
return reinterpret_cast< nsDerivedSafe<nsISupports>* >(mRawPtr);
}
operator nsDerivedSafe<nsISupports>*() const
{
return get();
}
nsDerivedSafe<nsISupports>*
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<nsISupports>*
get_address()
{
return this;
}
const nsCOMPtr<nsISupports>*
get_address() const
{
return this;
}
private:
const nsCOMPtr<nsISupports>*
operator&() const
{
return this;
}
nsCOMPtr<nsISupports>*
operator&()
{
return this;
}
public:
nsDerivedSafe<nsISupports>&
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 <class T>
void
nsCOMPtr<T>::assign_with_AddRef( nsISupports* rawPtr )
{
if ( rawPtr )
(rawPtr)->AddRef();
assign_assuming_AddRef(reinterpret_cast< T* >(rawPtr));
}
template <class T>
void
nsCOMPtr<T>::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 <class T>
void**
nsCOMPtr<T>::begin_assignment()
{
assign_assuming_AddRef(0);
return reinterpret_cast< void** >(&mRawPtr);
}
template <class T>
inline
nsCOMPtr<T>*
address_of( nsCOMPtr<T>& aPtr )
{
return aPtr.get_address();
}
template <class T>
inline
const nsCOMPtr<T>*
address_of( const nsCOMPtr<T>& aPtr )
{
return aPtr.get_address();
}
template <class T>
class nsGetterAddRefs
{
public:
explicit
nsGetterAddRefs( nsCOMPtr<T>& 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<T>& mTargetSmartPtr;
};
template <>
class nsGetterAddRefs<nsISupports>
{
public:
explicit
nsGetterAddRefs( nsCOMPtr<nsISupports>& 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<nsISupports>& mTargetSmartPtr;
};
template <class T>
inline
nsGetterAddRefs<T>
getter_AddRefs( nsCOMPtr<T>& aSmartPtr )
{
return nsGetterAddRefs<T>(aSmartPtr);
}
template <class T, class U>
inline
NSCAP_BOOL
operator==( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
{
return static_cast< const void* >(lhs.get()) == static_cast< const void* >(rhs.get());
}
template <class T, class U>
inline
NSCAP_BOOL
operator!=( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
{
return static_cast< const void* >(lhs.get()) != static_cast< const void* >(rhs.get());
}
template <class T, class U>
inline
NSCAP_BOOL
operator==( const nsCOMPtr<T>& lhs, const U* rhs )
{
return static_cast< const void* >(lhs.get()) == static_cast< const void* >(rhs);
}
template <class T, class U>
inline
NSCAP_BOOL
operator==( const U* lhs, const nsCOMPtr<T>& rhs )
{
return static_cast< const void* >(lhs) == static_cast< const void* >(rhs.get());
}
template <class T, class U>
inline
NSCAP_BOOL
operator!=( const nsCOMPtr<T>& lhs, const U* rhs )
{
return static_cast< const void* >(lhs.get()) != static_cast< const void* >(rhs);
}
template <class T, class U>
inline
NSCAP_BOOL
operator!=( const U* lhs, const nsCOMPtr<T>& rhs )
{
return static_cast< const void* >(lhs) != static_cast< const void* >(rhs.get());
}
template <class T, class U>
inline
NSCAP_BOOL
operator==( const nsCOMPtr<T>& lhs, U* rhs )
{
return static_cast< const void* >(lhs.get()) == static_cast< void* >(rhs);
}
template <class T, class U>
inline
NSCAP_BOOL
operator==( U* lhs, const nsCOMPtr<T>& rhs )
{
return static_cast< void* >(lhs) == static_cast< const void* >(rhs.get());
}
template <class T, class U>
inline
NSCAP_BOOL
operator!=( const nsCOMPtr<T>& lhs, U* rhs )
{
return static_cast< const void* >(lhs.get()) != static_cast< void* >(rhs);
}
template <class T, class U>
inline
NSCAP_BOOL
operator!=( U* lhs, const nsCOMPtr<T>& rhs )
{
return static_cast< void* >(lhs) != static_cast< const void* >(rhs.get());
}
class NSCAP_Zero;
template <class T>
inline
NSCAP_BOOL
operator==( const nsCOMPtr<T>& lhs, NSCAP_Zero* rhs )
{
return static_cast< const void* >(lhs.get()) == reinterpret_cast< const void* >(rhs);
}
template <class T>
inline
NSCAP_BOOL
operator==( NSCAP_Zero* lhs, const nsCOMPtr<T>& rhs )
{
return reinterpret_cast< const void* >(lhs) == static_cast< const void* >(rhs.get());
}
template <class T>
inline
NSCAP_BOOL
operator!=( const nsCOMPtr<T>& lhs, NSCAP_Zero* rhs )
{
return static_cast< const void* >(lhs.get()) != reinterpret_cast< const void* >(rhs);
}
template <class T>
inline
NSCAP_BOOL
operator!=( NSCAP_Zero* lhs, const nsCOMPtr<T>& rhs )
{
return reinterpret_cast< const void* >(lhs) != static_cast< const void* >(rhs.get());
}
inline
NSCAP_BOOL
SameCOMIdentity( nsISupports* lhs, nsISupports* rhs )
{
return nsCOMPtr<nsISupports>( do_QueryInterface(lhs) ) == nsCOMPtr<nsISupports>( do_QueryInterface(rhs) );
}
template <class SourceType, class DestinationType>
inline
nsresult
CallQueryInterface( nsCOMPtr<SourceType>& 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 <class DestinationType>
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<DestinationType>::GetIID(),
reinterpret_cast< void** >(aDestination));
}
template <class DestinationType>
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<DestinationType>::GetIID(),
reinterpret_cast< void** >(aDestination));
}
template <class DestinationType>
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<DestinationType>::GetIID(),
reinterpret_cast< void** >(aDestination));
}
template <class DestinationType>
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<DestinationType>::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 <class DestinationType>
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<DestinationType>::GetIID(),
reinterpret_cast< nsISupports** >(aDestination),
shutdownListener);
}
template <class DestinationType>
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<DestinationType>::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<nsIServiceManager> 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<nsIServiceManager> 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<nsIServiceManager> mServiceManager;
nsresult* mErrorPtr;
};
inline
const nsGetServiceFromCategory
do_GetServiceFromCategory( const char* category, const char* entry,
nsresult* error = 0)
{
return nsGetServiceFromCategory(category, entry, 0, error);
}
template <class DestinationType>
inline
nsresult
CallGetService( const nsCID &aClass,
DestinationType** aDestination)
{
if (!(aDestination)) nsDebug::PreCondition("null parameter", "aDestination", "../../dist/include/xpcom/nsIServiceManagerUtils.h", 154);
nsCOMPtr<nsIServiceManager> mgr;
nsresult rv = NS_GetServiceManager(getter_AddRefs(mgr));
if (((rv) & 0x80000000))
return rv;
return mgr->GetService(aClass,
nsCOMTypeInfo<DestinationType>::GetIID(),
reinterpret_cast< void** >(aDestination));
}
template <class DestinationType>
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<nsIServiceManager> mgr;
nsresult rv = NS_GetServiceManager(getter_AddRefs(mgr));
if (((rv) & 0x80000000))
return rv;
return mgr->GetServiceByContractID(aContractID,
nsCOMTypeInfo<DestinationType>::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 T>
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 <class T>
PRBool
operator==( const nsCppSharedAllocator<T>&, const nsCppSharedAllocator<T>& )
{
return 1;
}
template <class T>
PRBool
operator!=( const nsCppSharedAllocator<T>&, const nsCppSharedAllocator<T>& )
{
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<PRUnichar> 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 CharT>
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 CharT>
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 CharT>
class nsStringAllocator
{
public:
virtual void Deallocate( CharT* ) const = 0;
};
nsStringAllocator<char>& StringAllocator_char();
nsStringAllocator<PRUnichar>& StringAllocator_wchar_t();
template <class T>
struct nsStringAllocatorTraits
{
};
template <>
struct nsStringAllocatorTraits<char>
{
static nsStringAllocator<char>& global_string_allocator() { return StringAllocator_char(); }
};
template <>
struct nsStringAllocatorTraits<PRUnichar>
{
static nsStringAllocator<PRUnichar>& global_string_allocator() { return StringAllocator_wchar_t(); }
};
template <class CharT>
class nsSharedBufferHandle
: public nsBufferHandle<CharT>
{
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<CharT>(aDataStart, aDataEnd),
mFlags(0),
mStorageLength(aStorageLength)
{
if ( isSingleAllocation )
mFlags |= kIsSingleAllocationWithBuffer;
}
~nsSharedBufferHandle();
void
AcquireReference() const
{
nsSharedBufferHandle<CharT>* mutable_this = const_cast< nsSharedBufferHandle<CharT>* >(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<CharT>& get_allocator() const;
};
template <class CharT>
class nsSharedBufferHandleWithAllocator
: public nsSharedBufferHandle<CharT>
{
public:
typedef PRUint32 size_type;
nsSharedBufferHandleWithAllocator( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength, nsStringAllocator<CharT>& aAllocator )
: nsSharedBufferHandle<CharT>(aDataStart, aDataEnd,
aStorageLength, 0),
mAllocator(aAllocator)
{
this->mFlags |= this->kIsUserAllocator;
}
nsStringAllocator<CharT>& get_allocator() const { return mAllocator; }
protected:
nsStringAllocator<CharT>& mAllocator;
};
template <class CharT>
class nsSharedBufferHandleWithDestroy
: public nsSharedBufferHandle<CharT>
{
public:
typedef PRUint32 size_type;
nsSharedBufferHandleWithDestroy( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength)
: nsSharedBufferHandle<CharT>(aDataStart, aDataEnd,
aStorageLength, 0)
{
this->mFlags |=
this->kIsUserAllocator | this->kIsSingleAllocationWithBuffer;
}
virtual void Destroy() = 0;
virtual ~nsSharedBufferHandleWithDestroy() { }
};
template <class CharT>
class nsNonDestructingSharedBufferHandle
: public nsSharedBufferHandleWithDestroy<CharT>
{
public:
typedef PRUint32 size_type;
nsNonDestructingSharedBufferHandle( CharT* aDataStart, CharT* aDataEnd, size_type aStorageLength)
: nsSharedBufferHandleWithDestroy<CharT>(aDataStart, aDataEnd,
aStorageLength)
{
}
virtual void Destroy()
{
this->set_refcount(1);
}
};
template <class CharT>
nsStringAllocator<CharT>&
nsSharedBufferHandle<CharT>::get_allocator() const
{
if ( mFlags & kIsUserAllocator )
{
return reinterpret_cast< const nsSharedBufferHandleWithAllocator<CharT>* >(this)->get_allocator();
}
return nsStringAllocatorTraits<CharT>::global_string_allocator();
}
template <class CharT>
nsSharedBufferHandle<CharT>::~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 <class CharT>
void
nsSharedBufferHandle<CharT>::ReleaseReference() const
{
nsSharedBufferHandle<CharT>* mutable_this = const_cast< nsSharedBufferHandle<CharT>* >(this);
if ( !mutable_this->set_refcount( get_refcount()-1 ) )
{
if ( ~mFlags & (kIsUserAllocator|kIsSingleAllocationWithBuffer) )
delete mutable_this;
else
static_cast< nsSharedBufferHandleWithDestroy<CharT>* >(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 <class Iterator>
inline
PRBool
SameFragment( const Iterator& lhs, const Iterator& rhs )
{
return lhs.fragment().mStart == rhs.fragment().mStart;
}
template <class CharT> class nsReadingIterator;
size_t Distance( const nsReadingIterator<PRUnichar>&, const nsReadingIterator<PRUnichar>& );
size_t Distance( const nsReadingIterator<char>&, const nsReadingIterator<char>& );
typedef PRBool nsCharTraits_bool;
template <class CharT> struct nsCharTraits {};
template <>
struct nsCharTraits<PRUnichar>
{
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<char>
{
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 <class InputIterator>
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 <class CharT>
struct nsCharSourceTraits<CharT*>
{
typedef ptrdiff_t difference_type;
static
PRUint32
readable_distance( CharT* s )
{
return PRUint32(nsCharTraits<CharT>::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 <class OutputIterator>
struct nsCharSinkTraits
{
static
PRUint32
write( OutputIterator& iter, const typename OutputIterator::value_type* s, PRUint32 n )
{
return iter.write(s, n);
}
};
template <class CharT>
struct nsCharSinkTraits<CharT*>
{
static
PRUint32
write( CharT*& iter, const CharT* s, PRUint32 n )
{
nsCharTraits<CharT>::move(iter, s, n);
iter += n;
return n;
}
};
enum nsFragmentRequest { kPrevFragment, kFirstFragment, kLastFragment, kNextFragment, kFragmentAt };
template <class CharT>
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 <class CharT>
struct nsWritableFragment
{
CharT* mStart;
CharT* mEnd;
void* mFragmentIdentifier;
nsWritableFragment()
: mStart(0), mEnd(0), mFragmentIdentifier(0)
{
}
};
template <class CharT>
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<char>
{
typedef nsACString abstract_string_type;
typedef nsAPromiseCString abstract_promise_type;
typedef nsAFlatCString abstract_flat_type;
typedef const nsDependentCString literal_string_type;
};
template <class T>
inline
const T&
NS_MIN( const T& a, const T& b )
{
return b < a ? b : a;
}
template <class T>
inline
const T&
NS_MAX( const T& a, const T& b )
{
return a > b ? a : b;
}
template <class InputIterator, class T>
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 <class InputIterator, class OutputIterator>
inline
OutputIterator&
copy_string( InputIterator& first, const InputIterator& last, OutputIterator& result )
{
typedef nsCharSourceTraits<InputIterator> source_traits;
typedef nsCharSinkTraits<OutputIterator> 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 <class InputIterator, class OutputIterator>
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<typename OutputIterator::value_type>::move(result.get()-lengthToCopy, last.get()-lengthToCopy, lengthToCopy);
last.advance( -PRInt32(lengthToCopy) );
result.advance( -PRInt32(lengthToCopy) );
}
return result;
}
template <class CharT>
class nsReadingIterator
{
public:
typedef ptrdiff_t difference_type;
typedef CharT value_type;
typedef const CharT* pointer;
typedef const CharT& reference;
typedef nsReadableFragment<CharT> const_fragment_type;
typedef nsWritableFragment<CharT> fragment_type;
private:
friend class nsAString;
friend class nsACString;
typedef typename nsStringTraits<CharT>::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<CharT>&
operator++()
{
++mPosition;
normalize_forward();
return *this;
}
nsReadingIterator<CharT>
operator++( int )
{
nsReadingIterator<CharT> result(*this);
++mPosition;
normalize_forward();
return result;
}
nsReadingIterator<CharT>&
operator--()
{
normalize_backward();
--mPosition;
return *this;
}
nsReadingIterator<CharT>
operator--( int )
{
nsReadingIterator<CharT> 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<CharT>&
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 CharT>
class nsWritingIterator
{
public:
typedef ptrdiff_t difference_type;
typedef CharT value_type;
typedef CharT* pointer;
typedef CharT& reference;
typedef nsReadableFragment<CharT> const_fragment_type;
typedef nsWritableFragment<CharT> fragment_type;
private:
friend class nsAString;
friend class nsACString;
typedef typename nsStringTraits<CharT>::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<CharT>&
operator++()
{
++mPosition;
normalize_forward();
return *this;
}
nsWritingIterator<CharT>
operator++( int )
{
nsWritingIterator<CharT> result(*this);
++mPosition;
normalize_forward();
return result;
}
nsWritingIterator<CharT>&
operator--()
{
normalize_backward();
--mPosition;
return *this;
}
nsWritingIterator<CharT>
operator--( int )
{
nsWritingIterator<CharT> 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<CharT>&
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<value_type>::move(mPosition, s, n);
advance( difference_type(n) );
return n;
}
};
template <class CharT>
inline
void
nsReadingIterator<CharT>::normalize_forward()
{
while ( mPosition == mFragment.mEnd
&& mOwningString->GetReadableFragment(mFragment, kNextFragment) )
mPosition = mFragment.mStart;
}
template <class CharT>
inline
void
nsReadingIterator<CharT>::normalize_backward()
{
while ( mPosition == mFragment.mStart
&& mOwningString->GetReadableFragment(mFragment, kPrevFragment) )
mPosition = mFragment.mEnd;
}
template <class CharT>
inline
PRBool
operator==( const nsReadingIterator<CharT>& lhs, const nsReadingIterator<CharT>& rhs )
{
return lhs.get() == rhs.get();
}
template <class CharT>
inline
PRBool
operator!=( const nsReadingIterator<CharT>& lhs, const nsReadingIterator<CharT>& rhs )
{
return lhs.get() != rhs.get();
}
template <class CharT>
inline
void
nsWritingIterator<CharT>::normalize_forward()
{
while ( mPosition == mFragment.mEnd
&& mOwningString->GetWritableFragment(mFragment, kNextFragment) )
mPosition = mFragment.mStart;
}
template <class CharT>
inline
void
nsWritingIterator<CharT>::normalize_backward()
{
while ( mPosition == mFragment.mStart
&& mOwningString->GetWritableFragment(mFragment, kPrevFragment) )
mPosition = mFragment.mEnd;
}
template <class CharT>
inline
PRBool
operator==( const nsWritingIterator<CharT>& lhs, const nsWritingIterator<CharT>& rhs )
{
return lhs.get() == rhs.get();
}
template <class CharT>
inline
PRBool
operator!=( const nsWritingIterator<CharT>& lhs, const nsWritingIterator<CharT>& 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<char_type> buffer_handle_type;
typedef nsConstBufferHandle<char_type> const_buffer_handle_type;
typedef nsSharedBufferHandle<char_type> shared_buffer_handle_type;
typedef nsReadableFragment<char_type> const_fragment_type;
typedef nsWritableFragment<char_type> fragment_type;
typedef nsAString self_type;
typedef nsAString abstract_string_type;
typedef nsReadingIterator<char_type> const_iterator;
typedef nsWritingIterator<char_type> 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<char_type> buffer_handle_type;
typedef nsConstBufferHandle<char_type> const_buffer_handle_type;
typedef nsSharedBufferHandle<char_type> shared_buffer_handle_type;
typedef nsReadableFragment<char_type> const_fragment_type;
typedef nsWritableFragment<char_type> fragment_type;
typedef nsACString self_type;
typedef nsACString abstract_string_type;
typedef nsReadingIterator<char_type> const_iterator;
typedef nsWritingIterator<char_type> 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<Length())) nsDebug::Assertion("|CharAt| out-of-range", "i<Length()", "../../dist/include/string/nsASingleFragmentString.h", 189);
return operator[](i);
}
inline
nsASingleFragmentCString::char_type
nsASingleFragmentCString::CharAt( PRUint32 i ) const
{
if (!(i<Length())) nsDebug::Assertion("|CharAt| out-of-range", "i<Length()", "../../dist/include/string/nsASingleFragmentString.h", 197);
return operator[](i);
}
class nsAFlatString
: public nsASingleFragmentString
{
public:
virtual const char_type* get() const
{
const char_type* temp;
return BeginReading(temp);
}
};
class nsAFlatCString
: public nsASingleFragmentCString
{
public:
virtual const char_type* get() const
{
const char_type* temp;
return BeginReading(temp);
}
};
template <class CharT>
class nsAutoBufferHandle
{
public:
nsAutoBufferHandle() : mHandle(0) { }
nsAutoBufferHandle( const nsAutoBufferHandle<CharT>& aOther )
: mHandle(aOther.get())
{
if ( mHandle )
mHandle->AcquireReference();
}
explicit
nsAutoBufferHandle( const nsSharedBufferHandle<CharT>* aHandle )
: mHandle( const_cast< nsSharedBufferHandle<CharT>* >(aHandle) )
{
if ( mHandle )
mHandle->AcquireReference();
}
~nsAutoBufferHandle()
{
if ( mHandle )
mHandle->ReleaseReference();
}
nsAutoBufferHandle<CharT>&
operator=( const nsSharedBufferHandle<CharT>* rhs )
{
nsSharedBufferHandle<CharT>* old_handle = mHandle;
if ( (mHandle = const_cast< nsSharedBufferHandle<CharT>* >(rhs)) )
mHandle->AcquireReference();
if ( old_handle )
old_handle->ReleaseReference();
return *this;
}
nsAutoBufferHandle<CharT>&
operator=( const nsAutoBufferHandle<CharT>& rhs )
{
return operator=(rhs.get());
}
nsSharedBufferHandle<CharT>*
get() const
{
return mHandle;
}
operator nsSharedBufferHandle<CharT>*() const
{
return get();
}
nsSharedBufferHandle<CharT>*
operator->() const
{
return get();
}
private:
nsSharedBufferHandle<CharT>* mHandle;
};
template <class HandleT, class CharT>
inline
size_t
NS_AlignedHandleSize( const HandleT*, const CharT* )
{
return ((sizeof(HandleT) + sizeof(CharT) - 1) / sizeof(CharT)) * sizeof(CharT);
}
template <class HandleT, class CharT>
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 <class HandleT, class CharT>
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 <class HandleT, class StringT>
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 <class HandleT, class StringT>
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<char_type> 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<char_type> 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<nsIProperties>::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<nsIProperties> serv(do_GetService(kDirectoryServiceCID, &rv));
if (((rv) & 0x80000000)) return rv;
nsCOMPtr<nsISupports> dir;
rv = serv->Get(specialDirName, nsCOMTypeInfo<nsIFile>::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<char_type>::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<char_type>::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<nsIAtom> do_GetAtom(const char* isolatin1)
{ return NS_NewAtom(isolatin1); }
inline already_AddRefed<nsIAtom> 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<nsIAtom> do_GetAtom(const PRUnichar* unicode)
{ return NS_NewAtom(unicode); }
inline already_AddRefed<nsIAtom> 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<nsIAtom> do_GetAtom(const nsAReadableString& aString)
{ return NS_NewAtom(aString); }
inline already_AddRefed<nsIAtom> 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<anInt2) ? anInt1 : anInt2;
}
inline PRInt32 MaxInt(PRInt32 anInt1,PRInt32 anInt2){
return (anInt1<anInt2) ? anInt2 : anInt1;
}
inline void AddNullTerminator(nsStr& aDest) {
if(eTwoByte==aDest.mCharSize)
aDest.mUStr[aDest.mLength]=0;
else aDest.mStr[aDest.mLength]=0;
}
inline void Recycle( char* aBuffer) { nsMemory::Free(aBuffer); }
inline void Recycle( PRUnichar* aBuffer) { nsMemory::Free(aBuffer); }
inline PRUnichar GetCharAt(const nsStr& aDest,PRUint32 anIndex) {
if(anIndex<aDest.mLength) {
return (eTwoByte==aDest.mCharSize) ? aDest.mUStr[anIndex] : (PRUnichar)aDest.mStr[anIndex];
}
return 0;
}
class UTF8traits
{
public:
static PRBool isASCII(char c) { return (c & 0x80) == 0x00; }
static PRBool isInSeq(char c) { return (c & 0xC0) == 0x80; }
static PRBool is2byte(char c) { return (c & 0xE0) == 0xC0; }
static PRBool is3byte(char c) { return (c & 0xF0) == 0xE0; }
static PRBool is4byte(char c) { return (c & 0xF8) == 0xF0; }
static PRBool is5byte(char c) { return (c & 0xFC) == 0xF8; }
static PRBool is6byte(char c) { return (c & 0xFE) == 0xFC; }
};
class nsISizeOfHandler;
class nsString :
public nsAFlatString,
public nsStr {
public:
friend class nsCString;
friend class nsLinebreakConverter;
friend void ToLowerCase( nsString& );
friend void ToUpperCase( nsString& );
protected:
virtual const nsBufferHandle<PRUnichar>* GetFlatBufferHandle() const;
virtual const PRUnichar* GetReadableFragment( nsReadableFragment<PRUnichar>&, nsFragmentRequest, PRUint32 ) const;
virtual PRUnichar* GetWritableFragment( nsWritableFragment<PRUnichar>&, 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<<eTwoByte];
};
class NS_ConvertASCIItoUCS2
: public nsAutoString
{
public:
explicit
NS_ConvertASCIItoUCS2( const nsACString& aCString );
explicit
NS_ConvertASCIItoUCS2( const nsAFlatCString& aCString )
{
Init( aCString.get(), aCString.Length() );
}
explicit
NS_ConvertASCIItoUCS2( const char* aCString )
{
Init( aCString, ~PRUint32(0) );
}
NS_ConvertASCIItoUCS2( const char* aCString, PRUint32 aLength )
{
Init( aCString, aLength );
}
protected:
void Init( const char* aCString, PRUint32 aLength );
private:
NS_ConvertASCIItoUCS2( PRUnichar );
};
class NS_ConvertUTF8toUCS2
: public nsAutoString
{
public:
explicit
NS_ConvertUTF8toUCS2( const nsACString& aCString )
{
Init( aCString );
}
explicit
NS_ConvertUTF8toUCS2( const char* aCString )
{
Init( nsDependentCString( aCString ) );
}
NS_ConvertUTF8toUCS2( const char* aCString, PRUint32 aLength )
{
Init( nsDependentCString( aCString, aLength ) );
}
protected:
void Init( const nsACString& aCString );
private:
NS_ConvertUTF8toUCS2( PRUnichar );
};
class nsCString :
public nsAFlatCString,
public nsStr {
public:
friend class nsString;
friend void ToUpperCase( nsCString& );
friend void ToLowerCase( nsCString& );
protected:
virtual const nsBufferHandle<char>* GetFlatBufferHandle() const;
virtual const char* GetReadableFragment( nsReadableFragment<char>&, nsFragmentRequest, PRUint32 ) const;
virtual char* GetWritableFragment( nsWritableFragment<char>&, 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<nsIGenericFactory> mSoftwareUpdateFactory;
nsCOMPtr<nsIGenericFactory> mInstallTriggerFactory;
nsCOMPtr<nsIGenericFactory> mInstallVersionFactory;
};
inline PRBool
NS_SoftwareUpdateNeedsAutoReg()
{
nsresult rv;
PRBool needAutoReg = 1;
nsCOMPtr<nsIRegistry> 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<nsIRegistry> 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<nsIRegistry> 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<nsIXPIListener> 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<nsIFile> 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<nsIFile> 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<nsIFile> mFile;
nsCOMPtr<nsIXPIListener> mListener;
nsCOMPtr<nsIDOMWindowInternal> mParent;
nsCOMPtr<nsIChromeRegistry> 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<nsIFile> 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<nsIXPIListener> mListener;
nsCOMPtr<nsPIXPIProxy> mUIThreadProxy;
nsCOMPtr<nsIStringBundle> 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<nsISupports> 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<nsILocalFile> mFile;
nsCOMPtr<nsIOutputStream> 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<nsIXPConnectJSObjectHolder> 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<nsIInputStream> 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<nsIInputStream> mInputStream;
PRBool mEOF;
};
typedef nsInputStream nsBasicInStream;
class nsOutputStream
{
public:
nsOutputStream() {}
nsOutputStream(nsIOutputStream* inStream)
: mOutputStream(do_QueryInterface(inStream))
{}
virtual ~nsOutputStream();
nsCOMPtr<nsIOutputStream> 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<nsIOutputStream> 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<nsIOpenFile>& 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<nsIOpenFile> mFile;
};
class nsRandomAccessStoreClient
: public virtual nsErrorProne
{
public:
nsRandomAccessStoreClient()
{
}
nsRandomAccessStoreClient(const nsCOMPtr<nsIRandomAccessStore>& 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<nsIRandomAccessStore> 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<nsIFileSpecInputStream> 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<nsIFileSpecOutputStream> 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<nsIFileSpecOutputStream> 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<nsIFile> 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<nsIEventQueue> mDestQueue;
nsCOMPtr<nsISupports> mRealObject;
nsCOMPtr<nsIEventQueueService> 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<nsIEventQueue> mCallersEventQ;
nsCOMPtr<nsProxyObject> 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<nsIProxyObjectManager> 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<nsISupports> mProxiedService;
nsCOMPtr<nsISupports> 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<nsIFile> 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<nsIProperties> directoryService =
do_GetService("@mozilla.org/file/directory_service;1", &rv);
if(!directoryService) return;
nsCOMPtr<nsILocalFile> dir;
directoryService->Get("XCurProcD", nsCOMTypeInfo<nsIFile>::GetIID(), getter_AddRefs(dir));
if (dir)
{
char* nativePath;
dir->GetPath(&nativePath);
VR_SetRegDirectory( nativePath );
if (nativePath)
nsMemory::Free(nativePath);
}
nsCOMPtr<nsIObserverService> 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<nsISoftwareUpdate>::GetIID()) ) foundInterface = static_cast< nsISoftwareUpdate* >(this); else if ( aIID.Equals(nsCOMTypeInfo<nsPIXPIStubHook>::GetIID()) ) foundInterface = static_cast< nsPIXPIStubHook* >(this); else if ( aIID.Equals(nsCOMTypeInfo<nsIObserver>::GetIID()) ) foundInterface = static_cast< nsIObserver* >(this); else if ( aIID.Equals(nsCOMTypeInfo<nsISupports>::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<nsILocalFile> pathToCleanupUtility;
nsCOMPtr<nsIProperties> directoryService =
do_GetService("@mozilla.org/file/directory_service;1", &rv);
directoryService->Get("CurProcD",
nsCOMTypeInfo<nsIFile>::GetIID(),
getter_AddRefs(pathToCleanupUtility));
pathToCleanupUtility->Append("xpicleanup");
nsCOMPtr<nsIProcess> 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<nsIChromeRegistry>::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<nsIChromeRegistry>::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<nsIRegistry> 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<nsIScriptExternalNameSet>::GetIID()) ) foundInterface = static_cast< nsIScriptExternalNameSet* >(this); else if ( aIID.Equals(nsCOMTypeInfo<nsISupports>::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<nsICategoryManager> 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:
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2002-11-05 16:33 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2002-11-05 8:33 c++/5602: g++3.0.3 internal compiler error emit_move_insn_1, at expr.c:2975 bangerth
-- strict thread matches above, loose matches on Subject: below --
2002-02-05 19:56 Mathew Yeates
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).