This is a copy of regalloc_code2_BRANCH from Netscape's private repository,

as it existed in January of 1998.


git-svn-id: svn://10.0.0.236/branches/regalloc_code2_BRANCH@22571 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/ef/Compiler/RegisterAllocator/BitSet.cpp

@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "BitSet.h"
+
+// Return the next bit after index set to true or -1 if none.
+//
+Int32 BitSet::nextOne(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(0)) {
+		while ((currentWord & Word(1)) == 0) {
+			++index;
+			currentWord >>= 1;
+		}
+		return (offset << nBitsInWordLog2) + index;
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(0)) {
+			index = 0;
+			while ((currentWord & Word(1)) == 0) {
+				++index;
+				currentWord >>= 1;
+			}
+			return (offset << nBitsInWordLog2) + index;
+		}
+	}
+	return -1;
+}
+
+// Return the next bit after index set to false or -1 if none.
+//
+Int32 BitSet::nextZero(Int32 pos) const
+{
+	++pos;
+
+	if (pos < 0 || Uint32(pos) >= universeSize)
+		return -1;
+
+	Uint32 offset = getWordOffset(pos);
+	Uint8 index = getBitOffset(pos);
+	Word* ptr = &word[offset];
+	Word currentWord = *ptr++ >> index;
+	
+	if (currentWord != Word(~0)) {
+		for (; index < nBitsInWord; ++index) {
+			if ((currentWord & Word(1)) == 0) {
+				Int32 ret = (offset << nBitsInWordLog2) + index;
+				return (Uint32(ret) < universeSize) ? ret : -1;
+			}
+			currentWord >>= 1;
+		}
+	}
+
+	Word* limit = &word[getSizeInWords(universeSize)];
+	while (ptr < limit) {
+		++offset;
+		currentWord = *ptr++;
+		if (currentWord != Word(~0)) {
+			for (index = 0; index < nBitsInWord; ++index) {
+				if ((currentWord & Word(1)) == 0) {
+					Int32 ret = (offset << nBitsInWordLog2) + index;
+					return (Uint32(ret) < universeSize) ? ret : -1;
+				}
+				currentWord >>= 1;
+			}
+		}
+	}
+	return -1;
+}
+
+#ifdef DEBUG_LOG
+
+// Print the set.
+//
+void BitSet::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("[ "));
+
+	for (Int32 i = firstOne(); i != -1; i = nextOne(i)) {
+		Int32 currentBit = i;
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", currentBit));
+
+		Int32 nextBit = nextOne(currentBit);
+		if (nextBit != currentBit + 1) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" "));
+			continue;
+		}
+		  
+		while ((nextBit != -1) && (nextBit == (currentBit + 1))) {
+			currentBit = nextBit;
+			nextBit = nextOne(nextBit);
+		}
+
+		if (currentBit > (i+1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("-%d ", currentBit));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" %d ", currentBit));
+
+		i = currentBit;
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("]\n"));
+}
+
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/BitSet.h

@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _BITSET_H_
+#define _BITSET_H_
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "Pool.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// BitSet -
+
+class BitSet
+{
+private:
+
+#if (PR_BITS_PER_WORD == 64)
+	typedef Uint64 Word;
+#elif (PR_BITS_PER_WORD == 32)
+	typedef Uint32 Word;
+#endif
+
+	static const nBitsInWord = 		PR_BITS_PER_WORD;
+	static const nBytesInWord = 	PR_BYTES_PER_WORD;
+	static const nBitsInWordLog2 =	PR_BITS_PER_WORD_LOG2;
+	static const nBytesInWordLog2 = PR_BYTES_PER_WORD_LOG2;
+
+	// Return the number of Word need to store the universe.
+	static Uint32 getSizeInWords(Uint32 sizeOfUniverse) {return (sizeOfUniverse + (nBitsInWord - 1)) >> nBitsInWordLog2;}
+	// Return the given element offset in its containing Word.
+	static Uint32 getBitOffset(Uint32 element) {return element & (nBitsInWord - 1);}
+	// Return the Word offset for the given element int the universe.
+	static Uint32 getWordOffset(Uint32 element) {return element >> nBitsInWordLog2;}
+	// Return the mask for the given bit index.
+	static Word getMask(Uint8 index) {return Word(1) << index;}
+	
+private:
+
+	Uint32							universeSize;			// Size of the universe
+	Word*							word;					// universe memory.
+
+private:
+
+	// No copy constructor.
+	BitSet(const BitSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const BitSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	// Create a bitset of universeSize bits.
+	BitSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {word = new(pool) Word[getSizeInWords(universeSize)]; clear();}
+
+	// Return the size of this bitset.
+	Uint32 getSize() const {return universeSize;}
+
+	// Clear the bitset.
+	void clear() {memset(word, 0x00, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Clear the bit at index.
+	void clear(Uint32 index) {checkMember(index); word[getWordOffset(index)] &= ~getMask(index);}
+	// Set the bitset.
+	void set() {memset(word, 0xFF, getSizeInWords(universeSize) << nBytesInWordLog2);}
+	// Set the bit at index.
+	void set(Uint32 index) {checkMember(index); word[getWordOffset(index)] |= getMask(index);}
+	// Return true if the bit at index is set.
+	bool test(Uint32 index) const {checkMember(index); return (word[getWordOffset(index)] & getMask(index)) != 0;}
+	// Union with the given bitset.
+	inline void or(const BitSet& set);
+	// Intersection with the given bitset.
+	inline void and(const BitSet& set);
+	// Difference with the given bitset.
+	inline void difference(const BitSet& set);
+	// Copy set.
+	inline BitSet& operator = (const BitSet& set);
+	// Return true if the bitset are identical.
+	friend bool operator == (const BitSet& set1, const BitSet& set2);
+	// Return true if the bitset are different.
+	friend bool operator != (const BitSet& set1, const BitSet& set2);
+
+	// Logical operators.
+	BitSet& operator |= (const BitSet& set) {or(set); return *this;}
+	BitSet& operator &= (const BitSet& set) {and(set); return *this;}
+	BitSet& operator -= (const BitSet& set) {difference(set); return *this;}
+
+	// Return the first bit at set to true or -1 if none.
+	Int32 firstOne() const {return nextOne(-1);}
+	// Return the next bit after index set to true or -1 if none.
+	Int32 nextOne(Int32 pos) const;
+	// Return the first bit at set to false or -1 if none.
+	Int32 firstZero() const {return nextZero(-1);}
+	// Return the next bit after index set to false or -1 if none.
+	Int32 nextZero(Int32 pos) const;
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return true if the walk is ordered.
+	static bool isOrdered() {return true;}
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return firstOne();}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return nextOne(pos);}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == -1;}
+	// Return the element corresponding to the given iterator.
+	Uint32 get(iterator pos) const {return pos;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// Union with the given bitset.
+//
+inline void  BitSet::or(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ |= *src++;
+}
+
+// Intersection with the given bitset.
+//
+inline void  BitSet::and(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= *src++;
+}
+
+// Difference with the given bitset.
+//
+inline void BitSet::difference(const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	Word* src = set.word;
+	Word* dst = word;
+	Word* limit = &src[getSizeInWords(universeSize)];
+
+	while (src < limit)
+		*dst++ &= ~*src++;
+}
+
+// Copy the given set into this set.
+//
+inline BitSet& BitSet::operator = (const BitSet& set)
+{
+	checkUniverseCompatibility(set);
+	if (this != &set)
+		memcpy(word, set.word, getSizeInWords(universeSize) << nBytesInWordLog2);
+	return *this;
+}
+
+// Return true if the given set is identical to this set.
+inline bool operator == (const BitSet& set1, const BitSet& set2)
+{
+	set1.checkUniverseCompatibility(set2);
+
+	if (&set1 == &set2)
+		return true;
+
+	return memcmp(set1.word, set2.word, BitSet::getSizeInWords(set1.universeSize) << BitSet::nBytesInWordLog2) == 0;
+}
+
+inline bool operator != (const BitSet& set1, const BitSet& set2) {return !(set1 == set2);}
+
+#endif // _BITSET_H

mozilla/ef/Compiler/RegisterAllocator/Coalescing.h

@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _COALESCING_H_
+#define _COALESCING_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "RegisterPressure.h"
+#include "InterferenceGraph.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+#if 1
+// Performing an ultra conservative coalescing meens that when we look at
+// candidates (source,destination) for coalescing we need to make sure
+// that the combined interference of the source and destination register
+// will not exceed the total number of register available for the register
+// class. 
+#define ULTRA_CONSERVATIVE_COALESCING
+#else
+// If we are not doing an ultra conservative coalescing we have to make sure 
+// that the total number of neighbor whose degree is greater than the total 
+// number of register is not greater than the total number of register.
+#undef ULTRA_CONSERVATIVE_COALESCING
+#endif
+
+template <class RegisterPressure>
+struct Coalescing
+{
+	static bool coalesce(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+bool Coalescing<RegisterPressure>::coalesce(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+
+   	// Initialize the lookup table
+	//
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* newRange = new RegisterName[2 * rangeCount];
+	RegisterName* coalescedRange = &newRange[rangeCount];
+	RegisterName* name2range = registerAllocator.name2range;
+
+	init(coalescedRange, rangeCount);
+
+	SparseSet interferences(pool, rangeCount);
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	bool removedInstructions = false;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.lndList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+
+	// Walk the nodes in the loop nesting depth list.
+	for (Int32 n = nNodes - 1; n >= 0; n--) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		InstructionList::iterator it = instructions.begin();
+		while (!instructions.done(it)) {
+			Instruction& instruction = instructions.get(it);
+			it = instructions.advance(it);
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+
+				RegisterName source = findRoot(name2range[instruction.getInstructionUseBegin()[0].getRegisterName()], coalescedRange);
+				RegisterName destination = findRoot(name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()], coalescedRange);
+
+				if (source == destination) {
+					instruction.remove();
+				} else if (!iGraph.interfere(source, destination)) {
+					InterferenceVector* sourceVector = iGraph.getInterferenceVector(source);
+					InterferenceVector* destinationVector = iGraph.getInterferenceVector(destination);
+
+#ifdef ULTRA_CONSERVATIVE_COALESCING
+					interferences.clear();
+
+					InterferenceVector* vector;
+					for (vector = sourceVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+					for (vector = destinationVector; vector != NULL; vector = vector->next) {
+						RegisterName* neighbors = vector->neighbors;
+						for (Uint32 i = 0; i < vector->count; i++)
+							interferences.set(findRoot(neighbors[i], coalescedRange));
+					}
+
+					Uint32 count = interferences.getSize();
+#else // ULTRA_CONSERVATIVE_COALESCING
+					trespass("not implemented");
+					Uint32 count = 0;
+#endif // ULTRA_CONSERVATIVE_COALESCING
+
+					if (count < 6 /* FIX: should get the number from the class */) {
+						// Update the interferences vector.
+						if (sourceVector == NULL) {
+							iGraph.setInterferenceVector(source, destinationVector);
+							sourceVector = destinationVector;
+						} else if (destinationVector == NULL)
+							iGraph.setInterferenceVector(destination, sourceVector);
+						else {
+							InterferenceVector* last = NULL;
+							for (InterferenceVector* v = sourceVector; v != NULL; v = v->next)
+								last = v;
+							assert(last);
+							last->next = destinationVector;
+							iGraph.setInterferenceVector(destination, sourceVector);
+						}
+						// Update the interference matrix.
+						for (InterferenceVector* v = sourceVector; v != NULL; v = v->next) {
+							RegisterName* neighbors = v->neighbors;
+							for (Uint32 i = 0; i < v->count; i++) {
+								RegisterName neighbor = findRoot(neighbors[i], coalescedRange);
+								iGraph.setInterference(neighbor, source);
+								iGraph.setInterference(neighbor, destination);
+							}
+						}
+
+						instruction.remove();
+						coalescedRange[source] = destination;
+						removedInstructions = true;
+					}
+				}
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, coalescedRange, registerAllocator.nameCount, rangeCount);
+	delete newRange;
+
+	return removedInstructions;
+}
+
+#endif // _COALESCING_H_

mozilla/ef/Compiler/RegisterAllocator/Coloring.cpp

@@ -0,0 +1,283 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+
+#include "Coloring.h"
+#include "VirtualRegister.h"
+#include "FastBitSet.h"
+#include "FastBitMatrix.h"
+#include "CpuInfo.h"
+
+bool Coloring::
+assignRegisters(FastBitMatrix& interferenceMatrix)
+{
+  PRUint32 *stackPtr = new(pool) PRUint32[vRegManager.count()];
+
+  return select(interferenceMatrix, stackPtr, simplify(interferenceMatrix, stackPtr));
+}
+
+PRInt32 Coloring::
+getLowestSpillCostRegister(FastBitSet& bitset)
+{
+  PRInt32 lowest = bitset.firstOne();
+  if (lowest != -1)
+	{
+	  Flt32 cost = vRegManager.getVirtualRegister(lowest).spillInfo.spillCost;
+	  for (PRInt32 r = bitset.nextOne(lowest); r != -1; r = bitset.nextOne(r))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+		  if (!vReg.spillInfo.infiniteSpillCost && (vReg.spillInfo.spillCost < cost))
+			{
+			  cost = vReg.spillInfo.spillCost;
+			  lowest = r;
+			}
+		}
+	}
+  return lowest;
+}
+
+PRUint32* Coloring::
+simplify(FastBitMatrix interferenceMatrix, PRUint32* stackPtr)
+{
+  // first we construct the sets low and high. low contains all nodes of degree
+  // inferior to the number of register available on the processor. All the
+  // nodes with an high degree and a finite spill cost are placed in high.
+  // Nodes of high degree and infinite spill cost are not included in either sets.
+
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet low(pool, nRegisters);
+  FastBitSet high(pool, nRegisters);
+  FastBitSet stack(pool, nRegisters);
+
+  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+	{
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+	  
+	  if (vReg.getClass() == vrcStackSlot)
+		{
+		  stack.set(i);
+		  vReg.colorRegister(nRegisters);
+		}
+	  else
+		{
+		  if (vReg.colorInfo.interferenceDegree < NUMBER_OF_REGISTERS)
+			low.set(i);
+		  else // if (!vReg.spillInfo.infiniteSpillCost)
+			high.set(i);
+
+		  // Set coloring info.
+		  vReg.spillInfo.willSpill = false;
+
+		  switch(vReg.getClass())
+			{
+			case vrcInteger:
+			  vReg.colorRegister(LAST_GREGISTER + 1);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  vReg.colorRegister(LAST_FPREGISTER + 1);
+			  break;
+			default:
+			  PR_ASSERT(false); // Cannot happen.
+			}
+		}
+	}
+
+  // push the stack registers
+  PRInt32 j;
+  for (j = stack.firstOne(); j != -1; j = stack.nextOne(j))
+	*stackPtr++ = j;
+
+  // simplify
+  while (true)
+	{
+	  PRInt32 r;
+	  while ((r = getLowestSpillCostRegister(low)) != -1)
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+		  /* update low and high */
+		  FastBitSet inter(interferenceMatrix.getRow(r), nRegisters);
+		  for (j = inter.firstOne(); j != -1; j = inter.nextOne(j))
+			{
+			  VirtualRegister& neighbor = vRegManager.getVirtualRegister(j);
+			  // if the new interference degree of one of his neighbor becomes
+			  // NUMBER_OF_REGISTERS - 1 then it is added to the set 'low'.
+			  
+			  PRUint32 maxInterference = 0;
+			  switch (neighbor.getClass())
+				{
+				case vrcInteger:
+				  maxInterference = NUMBER_OF_GREGISTERS;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  maxInterference = NUMBER_OF_FPREGISTERS;
+				  break;
+				default:
+				  PR_ASSERT(false);
+				}
+			  if ((vRegManager.getVirtualRegister(j).colorInfo.interferenceDegree-- == maxInterference))
+				{
+				  high.clear(j);
+				  low.set(j);
+				}
+			  vReg.colorInfo.interferenceDegree--;
+			  interferenceMatrix.clear(r, j);
+			  interferenceMatrix.clear(j, r);
+			}
+		  low.clear(r);
+
+		  // Push this register.
+		  *stackPtr++ = r;
+		}
+	  if ((r = getLowestSpillCostRegister(high)) != -1)
+		{
+		  high.clear(r);
+		  low.set(r);
+		}
+	  else
+		break;
+	}
+
+  return stackPtr;
+}
+
+bool Coloring::
+select(FastBitMatrix& interferenceMatrix, PRUint32* stackBase, PRUint32* stackPtr)
+{
+  PRUint32 nRegisters = vRegManager.count();
+  FastBitSet usedRegisters(NUMBER_OF_REGISTERS + 1); // usedRegisters if used for both GR & FPR.
+  FastBitSet preColoredRegisters(NUMBER_OF_REGISTERS + 1);
+  FastBitSet usedStack(nRegisters + 1);
+  bool success = true;
+  Int32 lastUsedSSR = -1;
+
+  // select
+  while (stackPtr != stackBase)
+	{
+	  // Pop one register.
+	  PRUint32 r = *--stackPtr;
+	  VirtualRegister& vReg = vRegManager.getVirtualRegister(r);
+
+	  FastBitSet neighbors(interferenceMatrix.getRow(r), nRegisters);
+		  
+	  if (vReg.getClass() == vrcStackSlot)
+		// Stack slots coloring.
+		{
+		  usedStack.clear();
+
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			usedStack.set(vRegManager.getVirtualRegister(i).getColor());
+
+		  Int32 color = usedStack.firstZero();
+		  vReg.colorRegister(color);
+		  if (color > lastUsedSSR)
+			  lastUsedSSR = color;
+		}
+	  else
+		// Integer & Floating point register coloring.
+		{
+		  usedRegisters.clear();
+		  preColoredRegisters.clear();
+		  
+		  for (PRInt32 i = neighbors.firstOne(); i != -1; i = neighbors.nextOne(i))
+			{
+			  VirtualRegister& nvReg = vRegManager.getVirtualRegister(i);
+			  usedRegisters.set(nvReg.getColor());
+			  if (nvReg.isPreColored())
+				preColoredRegisters.set(nvReg.getPreColor());
+			}
+		  if (vReg.hasSpecialInterference)
+			usedRegisters |= vReg.specialInterference;
+
+		  PRInt8 c = -1;
+		  PRInt8 maxColor = 0;
+		  PRInt8 firstColor = 0;
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  firstColor = FIRST_GREGISTER;
+			  maxColor = LAST_GREGISTER;
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+			  firstColor = FIRST_FPREGISTER;
+			  maxColor = LAST_FPREGISTER;
+			  break;
+			default:
+			  PR_ASSERT(false);
+			}
+
+		  if (vReg.isPreColored())
+			{
+			  c = vReg.getPreColor();
+			  if (usedRegisters.test(c))
+				c = -1;
+			}
+		  else
+			{
+			  for (c = usedRegisters.nextZero(firstColor - 1); (c >= 0) && (c <= maxColor) && (preColoredRegisters.test(c)); 
+				   c = usedRegisters.nextZero(c)) {}
+			}
+
+		  if ((c >= 0) && (c <= maxColor))
+			{
+			  vReg.colorRegister(c);
+			}
+		  else
+			{
+			  VirtualRegister& stackRegister = vRegManager.newVirtualRegister(vrcStackSlot);
+			  vReg.equivalentRegister[vrcStackSlot] = &stackRegister;	  
+			  vReg.spillInfo.willSpill = true;
+			  success = false;
+			}
+		}
+	}
+  
+#ifdef DEBUG
+  if (success)
+	{
+	  for (VirtualRegisterManager::iterator i = vRegManager.begin(); !vRegManager.done(i); i = vRegManager.advance(i))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(i);
+		  switch (vReg.getClass())
+			{
+			case vrcInteger:
+			  if (vReg.getColor() > LAST_GREGISTER)
+				PR_ASSERT(false);
+			  break;
+			case vrcFloatingPoint:
+			case vrcFixedPoint:
+#if NUMBER_OF_FPREGISTERS != 0
+			  if (vReg.getColor() > LAST_FPREGISTER)
+				PR_ASSERT(false);
+#endif
+			  break;
+			default:
+			  break;
+			}
+		}
+	}
+#endif
+
+  vRegManager.nUsedStackSlots = lastUsedSSR + 1;
+  return success;
+}
+#endif // NEW_LAURENTM_CODE

mozilla/ef/Compiler/RegisterAllocator/Coloring.h

@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "VirtualRegister.h"
+#include "InterferenceGraph.h"
+#include "SparseSet.h"
+#include "Spilling.h"
+#include "Splits.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+class Coloring
+{
+private:
+	static RegisterName* simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack);
+	static bool select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr);
+
+public:
+	static bool color(RegisterAllocator& registerAllocator);
+	static void finalColoring(RegisterAllocator& registerAllocator);
+};
+
+
+template <class RegisterPressure>
+void Coloring<RegisterPressure>::finalColoring(RegisterAllocator& registerAllocator)
+{
+	RegisterName* color = registerAllocator.color;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					usePtr->setRegisterName(color[name2range[usePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = usePtr->getRegisterID();
+					setColoredRegister(rid);
+					usePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					definePtr->setRegisterName(color[name2range[definePtr->getRegisterName()]]);
+#ifdef DEBUG
+					RegisterID rid = definePtr->getRegisterID();
+					setColoredRegister(rid);
+					definePtr->setRegisterID(rid);
+#endif // DEBUG
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::select(RegisterAllocator& registerAllocator, RegisterName* coloringStack, RegisterName* coloringStackPtr)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* color = new RegisterName[rangeCount];
+	registerAllocator.color = color;
+
+	for (Uint32 r = 1; r < rangeCount; r++)
+		color[r] = RegisterName(6); // FIX;
+
+	// Color the preColored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID) {
+			color[name2range[getName(machinePtr->id)]] = machinePtr->color;
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill preColor range %d as %d\n", name2range[getName(machinePtr->id)], machinePtr->color));
+		}
+
+	SpillCost* cost = registerAllocator.spillCost;
+	Pool& pool = registerAllocator.pool;
+	SparseSet& spill = *new(pool) SparseSet(pool, rangeCount);
+	registerAllocator.willSpill = &spill;
+	SparseSet neighborColors(pool, 6); // FIX
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	bool coloringFailed = false;
+	while (coloringStackPtr > coloringStack) {
+		RegisterName range = *--coloringStackPtr;
+
+		if (!cost[range].infinite && cost[range].cost < 0) {
+			coloringFailed = true;
+			spill.set(range);
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, will spill.\n", range));
+		} else {
+			neighborColors.clear();
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = vector->count - 1; i >= 0; --i) {
+					RegisterName neighborColor = color[vector->neighbors[i]];
+					if (neighborColor < 6) // FIX
+						neighborColors.set(neighborColor);
+				}
+
+			if (neighborColors.getSize() == 6) { // FIX
+				coloringFailed = true;
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tfailed to color %d, ", range));
+
+				if (!Splits<RegisterPressure>::findSplit(registerAllocator, color, range)) {
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will spill.\n"));
+					spill.set(range);
+				} else
+					UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("will split.\n"));
+			} else {
+				for (Uint32 i = 0; i < 6; i++) // FIX
+					if (!neighborColors.test(i)) {
+						fprintf(stdout, "\twill color %d as %d\n", range, i);
+						color[range] = RegisterName(i);
+						break;
+					}
+			}
+		}
+	}
+
+#ifdef DEBUG_LOG
+	if (coloringFailed) {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring failed:\n"));
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\twill spill: "));
+		spill.printPretty(UT_LOG_MODULE(RegAlloc));
+	} else {
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring succeeded:\n"));
+		for (Uint32 i = 1; i < rangeCount; i++)
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\trange %d colored as %d\n", i, color[i]));
+	}
+#endif
+
+	return !coloringFailed;
+}
+
+template <class RegisterPressure>
+RegisterName* Coloring<RegisterPressure>::simplify(RegisterAllocator& registerAllocator, RegisterName* coloringStack)
+{
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+	SpillCost* spillCost = registerAllocator.spillCost;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+
+	Uint32* degree = new Uint32[rangeCount];
+	for (RegisterName i = RegisterName(1); i < rangeCount; i = RegisterName(i + 1)) {
+		InterferenceVector* vector = iGraph.getInterferenceVector(i);
+		degree[i] = (vector != NULL) ? vector->count : 0;
+	}
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet low(pool, rangeCount);
+	SparseSet high(pool, rangeCount);
+	SparseSet highInfinite(pool, rangeCount);
+	SparseSet preColored(pool, rangeCount);
+
+	// Get the precolored registers.
+	//
+	VirtualRegisterManager& vrManager = registerAllocator.vrManager;
+	RegisterName* name2range = registerAllocator.name2range;
+	PreColoredRegister* machineEnd = vrManager.getMachineRegistersEnd();
+	for (PreColoredRegister* machinePtr = vrManager.getMachineRegistersBegin(); machinePtr < machineEnd; machinePtr++)
+		if (machinePtr->id != invalidID)
+			preColored.set(name2range[getName(machinePtr->id)]);
+
+	// Insert the live ranges in the sets.
+	//
+	for (Uint32 range = 1; range < rangeCount; range++)
+		if (!preColored.test(range))
+			if (degree[range] < 6) // FIX
+				low.set(range);
+			else if (!spillCost[range].infinite)
+				high.set(range);
+			else
+				highInfinite.set(range);
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring sets:\n\tlow = "));
+	low.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thigh = "));
+	high.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\thighInfinite = "));
+	highInfinite.printPretty(UT_LOG_MODULE(RegAlloc));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tpreColored = "));
+	preColored.printPretty(UT_LOG_MODULE(RegAlloc));
+#endif // DEBUG_LOG
+
+	RegisterName* coloringStackPtr = coloringStack;
+
+	while (low.getSize() != 0 || high.getSize() != 0) {
+		while (low.getSize() != 0) {
+			RegisterName range = RegisterName(low.getOne());
+			low.clear(range);
+			*coloringStackPtr++ = range;
+
+			for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+				for (Int32 i = (vector->count - 1); i >= 0; --i) {
+					RegisterName neighbor = vector->neighbors[i];
+					degree[neighbor]--;
+
+					if (degree[neighbor] < 6) // FIX
+						if (high.test(neighbor)) {
+							high.clear(neighbor);
+							low.set(neighbor);
+						} else if (highInfinite.test(neighbor)) {
+							highInfinite.clear(neighbor);
+							low.set(neighbor);
+						}
+				}
+		}
+
+		if (high.getSize() != 0) {
+			RegisterName best = RegisterName(high.getOne());
+			double bestCost = spillCost[best].cost;
+			double bestDegree = degree[best];
+
+			// Choose the next best candidate.
+			//
+			for (SparseSet::iterator i = high.begin(); !high.done(i); i = high.advance(i)) {
+				RegisterName range = RegisterName(high.get(i));
+				double thisCost = spillCost[range].cost;
+				double thisDegree = degree[range];
+
+				if (thisCost * bestDegree < bestCost * thisDegree) {
+					best = range;
+					bestCost = thisCost;
+					bestDegree = thisDegree;
+				}
+			}
+			
+			high.clear(best);
+			low.set(best);
+		}
+ 	}
+	assert(highInfinite.getSize() == 0);
+
+	delete degree;
+
+#ifdef DEBUG_LOG
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("Coloring stack:\n\t"));
+	for (RegisterName* sp = coloringStack; sp < coloringStackPtr; ++sp)
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("%d ", *sp));
+	UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\n"));
+#endif // DEBUG_LOG
+
+	return coloringStackPtr;
+}
+
+
+template <class RegisterPressure>
+bool Coloring<RegisterPressure>::color(RegisterAllocator& registerAllocator)
+{
+	RegisterName* coloringStack = new RegisterName[registerAllocator.rangeCount];
+	return select(registerAllocator, coloringStack, simplify(registerAllocator, coloringStack));
+}

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.cpp

@@ -0,0 +1,212 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+
+#include "DominatorGraph.h"
+
+DominatorGraph::DominatorGraph(ControlGraph& controlGraph) : controlGraph(controlGraph)
+{
+	Uint32 nNodes = controlGraph.nNodes;
+
+	GtoV = new Uint32[nNodes + 1];
+	VtoG = new Uint32[nNodes + 1];
+
+	Uint32 v = 1;
+	for (Uint32 n = 0; n < nNodes; n++) {
+		VtoG[v] = n;
+		GtoV[n] = v++;
+	}
+
+	// Initialize all the 1-based arrays.
+	//
+	parent =	new Uint32[v];
+	semi =		new Uint32[v];
+	vertex =	new Uint32[v];
+	label =		new Uint32[v];
+	size =		new Uint32[v];
+	ancestor =	new Uint32[v];
+	child =		new Uint32[v];
+	dom =		new Uint32[v];
+	bucket =	new DGLinkedList*[v];
+
+	memset(semi, '\0', v * sizeof(Uint32));
+	memset(bucket, '\0', v * sizeof(DGLinkedList*));
+
+	vCount = v;
+
+	build();
+
+	delete parent;
+	delete semi;
+	delete vertex;
+	delete label;
+	delete size;
+	delete ancestor;
+	delete child;
+	delete dom;
+	delete bucket;
+}
+
+Uint32 DominatorGraph::DFS(Uint32 vx, Uint32 n)
+{
+	semi[vx] = ++n;
+	vertex[n] = label[vx] = vx;
+	ancestor[vx] = child[vx] = 0;
+	size[vx] = 1;
+
+
+	ControlNode& node = *controlGraph.dfsList[VtoG[vx]];
+	ControlEdge* successorEnd = node.getSuccessorsEnd();
+	for (ControlEdge* successorPtr = node.getSuccessorsBegin(); successorPtr < successorEnd; successorPtr++) {
+		Uint32 w = GtoV[successorPtr->getTarget().dfsNum];
+		if (semi[w] == 0) {
+			parent[w] = vx;
+			n = DFS(w, n);
+		}
+	}
+	return n;
+}
+
+void DominatorGraph::LINK(Uint32 vx, Uint32 w)
+{
+    Uint32 s = w;
+
+	while (semi[label[w]] < semi[label[child[s]]]) {
+		if (size[s] + size[child[child[s]]] >= (size[child[s]] << 1)) {
+			ancestor[child[s]] = s;
+			child[s] = child[child[s]];
+		} else {
+			size[child[s]] = size[s];
+			s = ancestor[s] = child[s];
+		}
+	}
+	label[s] = label[w];
+	size[vx] += size[w];
+	if(size[vx] < (size[w] << 1)) {
+		Uint32 t = s;
+		s = child[vx]; 
+		child[vx] = t;
+	}
+	while( s != 0 ) {
+		ancestor[s] = vx;
+		s = child[s];
+	}
+}
+
+
+void DominatorGraph::COMPRESS(Uint32 vx)
+{
+	if(ancestor[ancestor[vx]] != 0) {
+		COMPRESS(ancestor[vx]);
+		if(semi[label[ancestor[vx]]] < semi[label[vx]])
+			label[vx] = label[ancestor[vx]];
+		ancestor[vx] = ancestor[ancestor[vx]];
+	}
+}
+
+Uint32 DominatorGraph::EVAL(Uint32 vx)
+{
+	if(ancestor[vx] == 0) 
+		return label[vx];
+	COMPRESS(vx);
+	return (semi[label[ancestor[vx]]] >= semi[label[vx]]) ? label[vx] : label[ancestor[vx]];
+}
+
+void DominatorGraph::build()
+{
+	Uint32 n = DFS(GtoV[0], 0);
+	size[0] = label[0] = semi[0];
+
+	for (Uint32 i = n; i >= 2; i--) {
+		Uint32 w = vertex[i];
+
+		ControlNode& node = *controlGraph.dfsList[VtoG[w]];
+		const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+		for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p)) {
+			Uint32 vx = GtoV[predecessors.get(p).getSource().dfsNum];
+			Uint32 u = EVAL(vx);
+
+			if(semi[u] < semi[w])
+				semi[w] = semi[u];
+		}
+
+		DGLinkedList* elem = new DGLinkedList();
+		elem->next = bucket[vertex[semi[w]]];
+		elem->index = w;
+		bucket[vertex[semi[w]]] = elem;
+
+		LINK(parent[w], w);
+
+		elem = bucket[parent[w]];
+		while(elem != NULL) {
+			Uint32 vx = elem->index;
+			Uint32 u = EVAL(vx);
+			dom[vx] = (semi[u] < semi[vx]) ? u : parent[w];
+			elem = elem->next;
+		}
+	}
+
+	memset(size, '\0', n * sizeof(Uint32));
+	Pool& pool = controlGraph.pool;
+	nodes = new(pool) DGNode[n];
+
+	for(Uint32 j = 2; j <= n; j++) {
+		Uint32 w = vertex[j];
+		Uint32 d = dom[w];
+		if(d != vertex[semi[w]]) {
+			d = dom[d];
+			dom[w] = d;
+		}
+		size[d]++;
+	}
+	dom[GtoV[0]] = 0;
+
+	for (Uint32 k = 1; k <= n; k++) {
+		DGNode& node = nodes[VtoG[k]];
+		Uint32 count = size[k];
+		node.successorsEnd = node.successorsBegin = (count) ? new(pool) Uint32[count] : (Uint32*) 0;
+	}
+
+	for (Uint32 l = 2; l <= n; l++)
+		*(nodes[VtoG[dom[l]]].successorsEnd)++ = VtoG[l];
+}
+
+#ifdef DEBUG_LOG
+void DominatorGraph::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Dominator Graph:\n"));
+	Uint32 nNodes = controlGraph.nNodes;
+	for (Uint32 i = 0; i < nNodes; i++) {
+		DGNode& node = nodes[i];
+		if (node.successorsBegin !=  node.successorsEnd) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tN%d dominates ", i));
+			for (Uint32* successorsPtr = node.successorsBegin; successorsPtr < node.successorsEnd; successorsPtr++)
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d ", *successorsPtr));
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+
+#endif // DEBUG_LOG
+
+
+

mozilla/ef/Compiler/RegisterAllocator/DominatorGraph.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _DOMINATOR_GRAPH_H_
+#define _DOMINATOR_GRAPH_H_
+
+#include "LogModule.h"
+
+class ControlGraph;
+
+struct DGNode
+{
+	Uint32* successorsBegin;
+	Uint32* successorsEnd;
+};
+
+struct DGLinkedList
+{
+	DGLinkedList* next;
+	Uint32 index;
+};
+
+class DominatorGraph
+{
+private:
+
+	ControlGraph&	controlGraph;
+
+	Uint32			vCount;
+
+	Uint32*			VtoG;
+	Uint32*			GtoV;
+	Uint32*			parent;
+	Uint32*			semi;
+	Uint32*			vertex;
+	Uint32*			label;
+	Uint32*			size;
+	Uint32*			ancestor;
+	Uint32*			child;
+	Uint32*			dom;
+	DGLinkedList**	bucket;
+	DGNode*			nodes;
+	
+private:
+
+	void build();
+
+	Uint32 DFS(Uint32 vx, Uint32 n);
+	void LINK(Uint32 vx, Uint32 w);
+	void COMPRESS(Uint32 vx);
+	Uint32 EVAL(Uint32 vx);
+
+public:
+
+	DominatorGraph(ControlGraph& controlGraph);
+
+	Uint32* getSuccessorsBegin(Uint32 n) const {return nodes[n].successorsBegin;}
+	Uint32* getSuccessorsEnd(Uint32 n) const {return nodes[n].successorsEnd;}
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+#endif // _DOMINATOR_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/HashSet.cpp

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,4 +16,5 @@
  * Reserved.
  */
 
-#include "MacPrefix_debug.h"
+#include "Fundamentals.h"
+#include "HashSet.h"

mozilla/ef/Compiler/RegisterAllocator/HashSet.h

@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _HASH_SET_H_
+#define _HASH_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include <string.h>
+
+struct HashSetElement
+{
+	Uint32 index;
+	HashSetElement* next;
+};
+
+class HashSet
+{
+private:
+
+	static const hashSize = 64;
+
+	// Return the hash code for the given element index.
+	static Uint32 getHashCode(Uint32 index) {return index & (hashSize - 1);} // Could be better !
+
+private:
+
+	Pool&					allocationPool;
+	HashSetElement**		bucket;
+	HashSetElement*			free;
+
+private:
+
+	// No copy constructor.
+	HashSet(const HashSet&);
+	// No copy operator.
+	void operator = (const HashSet&);
+
+public:
+
+	// Create a new HashSet.
+	inline HashSet(Pool& pool, Uint32 universeSize);
+
+	// Clear the hashset.
+	void clear();
+	// Clear the element for the given index.
+	void clear(Uint32 index);
+	// Set the element for the given index.
+	void set(Uint32 index);
+	// Return true if the element at index is a member.
+	bool test(Uint32 index) const;
+	// Union with the given hashset.
+	inline void or(const HashSet& set);
+	// Intersection with the given hashset.
+	inline void and(const HashSet& set);
+	// Difference with the given hashset.
+	inline void difference(const HashSet& set);
+
+	// Logical operators.
+	HashSet& operator |= (const HashSet& set) {or(set); return *this;}
+	HashSet& operator &= (const HashSet& set) {and(set); return *this;}
+	HashSet& operator -= (const HashSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef HashSetElement* iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const;
+	// Return the next iterator.
+	iterator advance(iterator pos) const;
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos == NULL;}
+};
+
+
+inline HashSet::HashSet(Pool& pool, Uint32 /*universeSize*/)
+	: allocationPool(pool), free(NULL)
+{
+	bucket = new(pool) HashSetElement*[hashSize];
+	memset(bucket, '\0', sizeof(HashSetElement*));
+}
+
+#endif // _HASH_SET_H_

mozilla/ef/Compiler/RegisterAllocator/IndexedPool.h

@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INDEXED_POOL_H_
+#define _INDEXED_POOL_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include <stdlib.h>
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObjectSubclass> is an indexed pool of objects. The
+// template parameter 'IndexedObjectSubclass' must be a subclass of the struct
+// IndexedObject.
+// 
+// When the indexed pool is ask to allocate and initialize a new object (using
+// the operator new(anIndexedPool) it will zero the memory used to store the
+// object and initialize the field 'index' of this object to its position in
+// the pool.
+//
+// An object allocated by the indexed pool can be freed by calling the method
+// IndexedPool::release(IndexedElement& objectIndex).
+//
+// example:
+//
+//   IndexedPool<IndexedElement> elementPool;
+//
+//   IndexedElement& element1 = *new(elementPool) IndexedElement();
+//   IndexedElement& element2 = *new(elementPool) IndexedElement();
+//
+//   indexedPool.release(element1);
+//   IndexedElement& element3 = *new(elementPool) IndexedElement();
+//
+//  At this point element1 is no longer a valid object, element2 is at
+//  index 2 and element3 is at index 1.
+//
+
+//------------------------------------------------------------------------------
+// IndexedObject -
+//
+
+template<class Object>
+struct IndexedObject
+{
+	Uint32			index;				// Index in the pool.
+	Object*			next;				// Used to link IndexedObject together.
+
+	Uint32 getIndex() {return index;}
+};
+
+//------------------------------------------------------------------------------
+// IndexedPool<IndexedObject> -
+//
+
+template <class IndexedObject>
+class IndexedPool
+{
+private:
+
+	static const	blockSize = 4;		// Size of one block.
+
+	Uint32			nBlocks;			// Number of blocks in the pool.
+	IndexedObject**	block;				// Array of block pointers.
+	IndexedObject*  freeObjects;		// Chained list of free IndexedObjects.
+	Uint32			nextIndex;			// Index of the next free object in the last block. 
+
+private:
+
+	void allocateAnotherBlock();
+	IndexedObject& newObject();
+
+public:
+
+	IndexedPool() : nBlocks(0), block(NULL), freeObjects(NULL), nextIndex(1) {}
+	~IndexedPool();
+
+	IndexedObject& get(Uint32 index) const;
+	void release(IndexedObject& object);
+
+	void setSize(Uint32 size) {assert(size < nextIndex); nextIndex = size;}
+
+	// Return the universe size.
+	Uint32 getSize() {return nextIndex;}
+
+	friend void* operator new(size_t, IndexedPool<IndexedObject>& pool); // Needs to call newObject().
+};
+
+// Free all the memory allocated for this object.
+//
+template <class IndexedObject>
+IndexedPool<IndexedObject>::~IndexedPool()
+{
+	for (Uint32 n = 0; n < nBlocks; n++)
+		free(&((IndexedObject **) &block[n][n*blockSize])[-(n + 1)]);
+}
+
+// Release the given. This object will be iserted in the chained
+// list of free IndexedObjects. To minimize the fragmentation the chained list 
+// is ordered by ascending indexes.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::release(IndexedObject& object)
+{
+	Uint32 index = object.index;
+	IndexedObject* list = freeObjects;
+
+	assert(&object == &get(index)); // Make sure that object is owned by this pool.
+
+	if (list == NULL) { // The list is empty.
+		freeObjects = &object;
+		object.next = NULL;
+	} else { // The list contains at least 1 element.
+		if (index < list->index) { // insert as first element.
+			freeObjects = &object;
+			object.next = list;
+		} else { // Find this object's place.
+			while ((list->next) != NULL && (list->next->index < index))
+				list = list->next;
+
+			object.next = list->next;
+			list->next = &object;
+		}
+	}
+
+#ifdef DEBUG
+	// Sanity check to be sure that the list is correctly ordered.
+	for (IndexedObject* obj = freeObjects; obj != NULL; obj = obj->next)
+		if (obj->next != NULL)
+			assert(obj->index < obj->next->index);
+#endif
+}
+
+// Create a new block of IndexedObjects. We will allocate the memory to
+// store IndexedPool::blockSize IndexedObject and the new Array of block
+// pointers.
+// The newly created IndexedObjects will not be initialized.
+//
+template <class IndexedObject>
+void IndexedPool<IndexedObject>::allocateAnotherBlock()
+{
+	void* memory = (void *) malloc((nBlocks + 1) * sizeof(Uint32) + blockSize * sizeof(IndexedObject));
+
+	memcpy(memory, block, nBlocks * sizeof(Uint32));
+
+	block = (IndexedObject **) memory;
+	IndexedObject* objects = (IndexedObject *) &block[nBlocks + 1];
+
+	block[nBlocks] = &objects[-(nBlocks * blockSize)];
+	nBlocks++;
+}
+
+// Return the IndexedObject at the position 'index' in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::get(Uint32 index) const
+{
+	Uint32 blockIndex = index / blockSize;
+	assert(blockIndex < nBlocks);
+
+	return block[blockIndex][index];
+}
+
+// Return the reference of an unused object in the pool.
+//
+template <class IndexedObject>
+IndexedObject& IndexedPool<IndexedObject>::newObject()
+{
+	if (freeObjects != NULL) {
+		IndexedObject& newObject = *freeObjects;
+		freeObjects = newObject.next;
+		return newObject;
+	}
+	
+	Uint32 nextIndex = this->nextIndex++;
+	Uint32 blockIndex = nextIndex / blockSize;
+
+	while (blockIndex >= nBlocks)
+		allocateAnotherBlock();
+	
+	IndexedObject& newObject = block[blockIndex][nextIndex];
+	newObject.index = nextIndex;
+
+	return newObject;
+}
+
+// Return the address of the next unsused object in the given
+// indexed pool. The field index of the newly allocated object
+// will be initialized to the corresponding index of this object
+// in the pool.
+//
+template <class IndexedObject>
+void* operator new(size_t size, IndexedPool<IndexedObject>& pool)
+{
+	assert(size == sizeof(IndexedObject));
+	return (void *) &pool.newObject();
+}
+
+#endif // _INDEXED_POOL_H_

mozilla/ef/Compiler/RegisterAllocator/InterferenceGraph.h

@@ -0,0 +1,258 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _INTERFERENCE_GRAPH_H_
+#define _INTERFERENCE_GRAPH_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "SparseSet.h"
+#include <string.h>
+
+struct InterferenceVector
+{
+	Uint32				count;
+	InterferenceVector*	next;
+	RegisterName*		neighbors;
+
+	InterferenceVector() : count(0), next(NULL) {}
+};
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class InterferenceGraph
+{
+private:
+
+	RegisterAllocator&			registerAllocator;
+
+	RegisterPressure::Set*		interferences;
+	InterferenceVector**		vector;
+	Uint32*						offset;
+	Uint32 						rangeCount;
+
+private:
+
+	// No copy constructor.
+	InterferenceGraph(const InterferenceGraph&);
+	// No copy operator.
+	void operator = (const InterferenceGraph&);
+
+	// Check if reg is a member of the universe.
+	void checkMember(RegisterName name) {assert(name < rangeCount);}
+	// Return the edge index for the interference between name1 and name2.
+	Uint32 getEdgeIndex(RegisterName name1, RegisterName name2);
+
+public:
+	InterferenceGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	// Calculate the interferences.
+	void build();
+	// Return true if reg1 and reg2 interfere.
+	bool interfere(RegisterName name1, RegisterName name2);
+	// Return the interference vector for the given register or NULL if there is none.
+	InterferenceVector* getInterferenceVector(RegisterName name) {return vector[name];}
+	// Set the interference between name1 and name2.
+	void setInterference(RegisterName name1, RegisterName name2);
+	// Set the interference vector for the given register.
+	void setInterferenceVector(RegisterName name, InterferenceVector* v) {vector[name] = v;}
+
+
+#ifdef DEBUG_LOG
+	// Print the interferences.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	// Initialize the structures.
+	//
+	offset = new(pool) Uint32[rangeCount + 1];
+	vector = new(pool) InterferenceVector*[rangeCount];
+	memset(vector, '\0', sizeof(InterferenceVector*) * rangeCount);
+
+	Uint32 o = 0;
+	offset[0] = 0;
+	for (Uint32 i = 1; i <= rangeCount; ++i) {
+		offset[i] = o;
+		o += i;
+	}
+	
+	interferences = new(pool) RegisterPressure::Set(pool, (rangeCount * rangeCount) / 2);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure> liveness = Liveness<RegisterPressure>::analysis(controlGraph, rangeCount, name2range);
+	registerAllocator.liveness = liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			// Handle the copy instruction to avoid unnecessary interference between the 2 registers.
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			// Create the interferences.
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator e = currentLive.begin(); !currentLive.done(e); e = currentLive.advance(e)) {
+						RegisterName live = RegisterName(currentLive.get(e));
+
+						if ((live != define) && !interfere(live, define) && registerAllocator.canInterfere(live, define)) {
+
+							if (vector[define] == NULL)
+								vector[define] = new(pool) InterferenceVector();
+							vector[define]->count++;
+
+							if (vector[live] == NULL)
+								vector[live] = new(pool) InterferenceVector();
+							vector[live]->count++;
+
+							setInterference(live, define);
+						}
+					}
+				}
+
+			// Now update the liveness.
+			//
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	// Allocate the memory to store the interferences.
+	//
+	for (Uint32 e = 0; e < rangeCount; e++)
+		if (vector[e] != NULL) {
+			InterferenceVector& v = *vector[e];
+			v.neighbors = new(pool) RegisterName[v.count];
+			v.count = 0;
+		}
+
+	// Initialize the edges.
+	//
+	if (RegisterPressure::Set::isOrdered()) {
+		RegisterName name1 = RegisterName(0);
+
+		for (RegisterPressure::Set::iterator i = interferences->begin(); !interferences->done(i); i = interferences->advance(i)) {
+			Uint32 interferenceIndex = interferences->get(i);
+
+			while(interferenceIndex >= offset[name1 + 1])
+				name1 = RegisterName(name1 + 1);
+
+			assert((interferenceIndex >= offset[name1]) && (interferenceIndex < offset[name1 + 1]));
+
+			RegisterName name2 = RegisterName(interferenceIndex - offset[name1]);
+
+			assert(interfere(name1, name2));
+
+			InterferenceVector& vector1 = *vector[name1];
+			vector1.neighbors[vector1.count++] = name2;
+		
+			InterferenceVector& vector2 = *vector[name2];
+			vector2.neighbors[vector2.count++] = name1;
+		}
+	} else {
+		trespass("not Implemented"); // FIX: need one more pass to initialize the vectors.
+	}
+}
+
+template <class RegisterPressure>
+Uint32 InterferenceGraph<RegisterPressure>::getEdgeIndex(RegisterName name1, RegisterName name2)
+{
+	checkMember(name1); checkMember(name2);
+	assert(name1 != name2); // This is not possible.
+	return (name1 < name2) ? offset[name2] + name1 : offset[name1] + name2;
+}
+
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::setInterference(RegisterName name1, RegisterName name2)
+{
+	interferences->set(getEdgeIndex(name1, name2));
+}
+
+template <class RegisterPressure>
+bool InterferenceGraph<RegisterPressure>::interfere(RegisterName name1, RegisterName name2)
+{
+	return interferences->test(getEdgeIndex(name1, name2));
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void InterferenceGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Vectors:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		if (vector[i] != NULL) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tvr%d: (", i));
+			for (InterferenceVector* v = vector[i]; v != NULL; v = v->next)
+				for (Uint32 j = 0; j < v->count; j++) {
+					UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%d", v->neighbors[j]));
+					if (v->next != NULL || j != (v->count - 1))
+						UT_OBJECTLOG(log, PR_LOG_ALWAYS, (","));
+				}
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (")\n"));
+		}
+	}
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Interference Matrix:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && interfere(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _INTERFERENCE_GRAPH_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRange.h

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_H_
+#define _LIVE_RANGE_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+template <class RegisterPressure>
+struct LiveRange
+{
+	static void build(RegisterAllocator& registerAllocator);
+};
+
+template <class RegisterPressure>
+void LiveRange<RegisterPressure>::build(RegisterAllocator& registerAllocator)
+{
+	// Intialize the lookup table.
+	//
+	Uint32 nameCount = registerAllocator.nameCount;
+	RegisterName* nameTable = new(registerAllocator.pool) RegisterName[2*nameCount];
+	RegisterName* rangeName = &nameTable[nameCount];
+
+	init(rangeName, nameCount);
+
+	// Walk the graph.
+	//
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	SparseSet destination(registerAllocator.pool, nameCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+
+		destination.clear();
+		for (InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+			Instruction& phiNode = phiNodes.get(i);
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			destination.set(findRoot(phiNode.getInstructionDefineBegin()[0].getRegisterName(), rangeName));
+		}
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+			RegisterName destinationName = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+			RegisterName destinationRoot = findRoot(destinationName, rangeName);
+
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+				assert(usePtr->isRegister());
+				RegisterName sourceName = usePtr->getRegisterName();
+				RegisterName sourceRoot = findRoot(sourceName, rangeName);
+
+				if (sourceRoot != destinationRoot && !destination.test(sourceRoot))
+					rangeName[sourceRoot] = destinationRoot;
+			}
+		}
+	}
+
+	registerAllocator.rangeCount = compress(registerAllocator.name2range, rangeName, nameCount, nameCount);
+}
+
+#endif // _LIVE_RANGE_H_

mozilla/ef/Compiler/RegisterAllocator/LiveRangeGraph.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVE_RANGE_GRAPH_
+#define _LIVE_RANGE_GRAPH_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+class RegisterAllocator;
+
+template <class RegisterPressure>
+class LiveRangeGraph
+{
+private:
+
+	RegisterAllocator&		registerAllocator;
+
+	RegisterPressure::Set*	edges;
+	Uint32					rangeCount;
+
+public:
+	//
+	//
+	LiveRangeGraph(RegisterAllocator& registerAllocator) : registerAllocator(registerAllocator) {}
+
+	//
+	//
+	void build();
+
+	//
+	//
+	void addEdge(RegisterName name1, RegisterName name2);
+
+	//
+	//
+	bool haveEdge(RegisterName name1, RegisterName name2);
+
+#ifdef DEBUG_LOG
+	//
+	//
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::build()
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	this->rangeCount = rangeCount;
+
+	edges = new(pool) RegisterPressure::Set(pool, rangeCount * rangeCount);
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	RegisterName* name2range = registerAllocator.name2range;
+	LivenessInfo<RegisterPressure>& liveness = registerAllocator.liveness;
+	SparseSet currentLive(pool, rangeCount);
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		currentLive = liveness.liveOut[n];
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			if ((instruction.getFlags() & ifCopy) != 0) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				currentLive.clear(name2range[useBegin[0].getRegisterName()]);
+			}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister()) {
+					RegisterName define = name2range[definePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (define != live && registerAllocator.canInterfere(define, live))
+							addEdge(define, live);
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					currentLive.set(name2range[usePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName use = name2range[usePtr->getRegisterName()];
+
+					for (SparseSet::iterator l = currentLive.begin(); !currentLive.done(l); l = currentLive.advance(l)) {
+						RegisterName live = RegisterName(currentLive.get(l));
+						if (use != live && registerAllocator.canInterfere(use, live))
+							addEdge(use, live);
+					}
+				}
+		}
+	}
+}
+
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::addEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	edges->set(name1 * rangeCount + name2);
+}
+
+template <class RegisterPressure>
+bool LiveRangeGraph<RegisterPressure>::haveEdge(RegisterName name1, RegisterName name2)
+{
+	assert(name1 != name2);
+	return edges->test(name1 * rangeCount + name2);
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LiveRangeGraph<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Live ranges graph:\n"));
+	for (RegisterName name1 = RegisterName(1); name1 < rangeCount; name1 = RegisterName(name1 + 1)) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\t%d:\t", name1));
+		for (RegisterName name2 = RegisterName(1); name2 < rangeCount; name2 = RegisterName(name2 + 1))
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%c", ((name1 != name2) && haveEdge(name1, name2)) ? '1' : '0'));
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVE_RANGE_GRAPH_

mozilla/ef/Compiler/RegisterAllocator/Liveness.cpp

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,4 +16,6 @@
  * Reserved.
  */
 
-#include "MacPrefix_debug.h"
+#include "Fundamentals.h"
+#include "Liveness.h"
+

mozilla/ef/Compiler/RegisterAllocator/Liveness.h

@@ -0,0 +1,301 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _LIVENESS_H_
+#define _LIVENESS_H_
+
+#include "Fundamentals.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterTypes.h"
+
+// ----------------------------------------------------------------------------
+// LivenessInfo -
+
+template <class RegisterPressure>
+struct LivenessInfo
+{
+	RegisterPressure::Set*	liveIn;
+	RegisterPressure::Set*	liveOut;
+	DEBUG_LOG_ONLY(Uint32	size);
+
+#ifdef DEBUG_LOG
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+// ----------------------------------------------------------------------------
+// Liveness
+//
+// The liveness is defined by the following data-flow equations:
+//
+//		LiveIn(n) = LocalLive(n) U (LiveOut(n) - Killed(n)).
+//		LiveOut(n) = U LiveIn(s) (s a successor of n).
+//
+//	where LocalLive(n) is the set of used registers in the block n, Killed(n)
+//  is the set of defined registers in the block n, LiveIn(n) is the set of
+//  live registers at the begining of the block n and LiveOut(n) is the set
+//  of live registers at the end of the block n.
+//
+//
+// We will compute the liveness analysis in two stages:
+//
+//	1- Build LocalLive(n) (wich is an approximation of LiveIn(n)) and Killed(n) 
+//     for each block n.
+//  2- Perform a backward data-flow analysis to propagate the liveness information
+//     through the entire control-flow graph.
+//
+
+template <class RegisterPressure>
+struct Liveness
+{
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range);
+	static LivenessInfo<RegisterPressure> analysis(ControlGraph& controlGraph, Uint32 nameCount);
+};
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 rangeCount, const RegisterName* name2range)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, rangeCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = name2range[usePtr->getRegisterName()];
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(name2range[definePtr->getRegisterName()]);
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, rangeCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+template <class RegisterPressure>
+LivenessInfo<RegisterPressure> Liveness<RegisterPressure>::analysis(ControlGraph& controlGraph, Uint32 nameCount)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Allocate the temporary sets.
+	RegisterPressure::Set* killed = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* usedByPhiNodes = NULL;
+	
+	// Allocate the globals sets.
+	RegisterPressure::Set* liveIn = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+	RegisterPressure::Set* liveOut = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+	// First stage of the liveness analysis: Compute the sets LocalLive(stored in LiveIn) and Killed.
+	//
+	for (Uint32 n = 0; n < (nNodes - 1); n++) {
+		ControlNode& node = *nodes[n];
+
+		RegisterPressure::Set& currentLocalLive = liveIn[n];
+		RegisterPressure::Set& currentKilled = killed[n];
+		
+		InstructionList& phiNodes = node.getPhiNodeInstructions();
+
+		if ((usedByPhiNodes == NULL) && !phiNodes.empty())
+			usedByPhiNodes = new(pool) RegisterPressure::Set[nNodes](pool, nameCount);
+
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& phiNode = phiNodes.get(p);
+
+			InstructionDefine& define = phiNode.getInstructionDefineBegin()[0];
+			currentKilled.set(define.getRegisterName());
+
+			typedef DoublyLinkedList<ControlEdge> ControlEdgeList;
+			const ControlEdgeList& predecessors = node.getPredecessors();
+			ControlEdgeList::iterator p = predecessors.begin();
+			InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+			for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++, p = predecessors.advance(p))
+				if (usePtr->isRegister())
+					usedByPhiNodes[predecessors.get(p).getSource().dfsNum].set(usePtr->getRegisterName());
+		}
+
+		// Find the instructions contributions to the sets LocalLive and Killed.
+		//
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			// If a VirtualRegister is 'used' before being 'defined' then we add it to set LocalLive.
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					Uint32 index = usePtr->getRegisterName();
+
+					if (!currentKilled.test(index))
+						currentLocalLive.set(index);
+				}
+
+			// If a Virtualregister is 'defined' then we add it to the set Killed.
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					currentKilled.set(definePtr->getRegisterName());
+		}
+	}
+
+	// Second stage of the liveness analysis: We propagate the LiveIn & LiveOut through the entire 
+	// control-flow graph.
+	//
+	RegisterPressure::Set temp(pool, nameCount);
+
+	bool changed;
+	do {
+		changed = false;
+
+		// For all nodes is this graph except the endNode.
+		for (Int32 n = (nNodes - 2); n >= 0; n--) {
+			ControlNode& node = *nodes[n];
+
+			RegisterPressure::Set& currentLiveIn = liveIn[n];
+			RegisterPressure::Set& currentLiveOut = liveOut[n];
+
+			// Compute temp = Union of LiveIn(s) (s a successor of this node) | usedByPhiNodes(n).
+			// temp will be the new LiveOut(n).
+			Uint32 nSuccessors = node.nSuccessors();
+			if (nSuccessors != 0) {
+				temp = liveIn[node.nthSuccessor(0).getTarget().dfsNum];
+				for (Uint32 s = 1; s < nSuccessors; s++)
+					temp |= liveIn[node.nthSuccessor(s).getTarget().dfsNum];
+			} else 
+				temp.clear();
+
+			// Insert the phiNodes contribution.
+			if (usedByPhiNodes != NULL)
+				temp |= usedByPhiNodes[n];
+
+			// If temp and LiveOut(n) differ then set LiveOut(n) = temp and recalculate the
+			// new LiveIn(n).
+			if (currentLiveOut != temp) {
+				currentLiveOut = temp;
+				temp -= killed[n]; // FIX: could be optimized with one call to unionDiff !
+				temp |= currentLiveIn;
+			
+				if (currentLiveIn != temp) {
+					currentLiveIn = temp;
+					changed = true;
+				}
+			}
+		}
+	} while(changed);
+
+	LivenessInfo<RegisterPressure> liveness;
+	liveness.liveIn = liveIn;
+	liveness.liveOut = liveOut;
+	DEBUG_LOG_ONLY(liveness.size = nNodes);
+	return liveness;
+}
+
+#ifdef DEBUG_LOG
+template <class RegisterPressure>
+void LivenessInfo<RegisterPressure>::printPretty(LogModuleObject log)
+{
+	for (Uint32 n = 0; n < size; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Node N%d:\n\tliveIn = ", n));
+		liveIn[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\tliveOut = "));
+		liveOut[n].printPretty(log);
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+	}
+}
+#endif // DEBUG_LOG
+
+#endif // _LIVENESS_H_

mozilla/ef/Compiler/RegisterAllocator/Makefile

@@ -0,0 +1,40 @@
+#! gmake
+
+DEPTH			= ../..
+
+MODULE_NAME		= RegisterAllocator
+
+include $(DEPTH)/config/config.mk
+
+INCLUDES		+=										\
+	-I$(DEPTH)/Utilities/General						\
+	-I$(DEPTH)/Utilities/zlib							\
+	-I$(DEPTH)/Runtime/ClassReader						\
+	-I$(DEPTH)/Runtime/NativeMethods					\
+	-I$(DEPTH)/Runtime/System							\
+	-I$(DEPTH)/Runtime/ClassInfo						\
+	-I$(DEPTH)/Runtime/FileReader						\
+	-I$(DEPTH)/Compiler/PrimitiveGraph					\
+	-I$(DEPTH)/Compiler/FrontEnd						\
+	-I$(DEPTH)/Compiler/Optimizer						\
+	-I$(DEPTH)/Compiler/CodeGenerator					\
+	-I$(DEPTH)/Compiler/CodeGenerator/md				\
+	-I$(DEPTH)/Compiler/CodeGenerator/md/$(CPU_ARCH)	\
+	-I$(DEPTH)/Compiler/RegisterAllocator				\
+	-I$(DEPTH)/Driver/StandAloneJava					\
+	-I$(DEPTH)/Debugger									\
+	$(NULL)
+
+CXXSRCS 		=										\
+	RegisterAllocator.cpp								\
+	RegisterAllocatorTools.cpp							\
+	DominatorGraph.cpp									\
+	VirtualRegister.cpp									\
+	BitSet.cpp											\
+	SparseSet.cpp										\
+	$(NULL)
+
+
+include $(DEPTH)/config/rules.mk
+
+libs:: $(MODULE)

mozilla/ef/Compiler/RegisterAllocator/PhiNodeRemover.h

@@ -0,0 +1,392 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _PHI_NODE_REMOVER_H_
+#define _PHI_NODE_REMOVER_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "DominatorGraph.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h"
+#include "Liveness.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "SparseSet.h"
+#include <string.h>
+
+//------------------------------------------------------------------------------
+// RegisterNameNode -
+
+struct RegisterNameNode 
+{
+	RegisterNameNode*	next;
+	RegisterName		newName;
+	Uint32				nextPushed;
+};
+
+//------------------------------------------------------------------------------
+// CopyData -
+
+struct CopyData
+{
+	RegisterName		source;
+	RegisterClassKind	classKind;
+	Uint32				useCount;
+	bool				isLiveOut;
+	RegisterName		sourceNameToUse;
+	RegisterName		temporaryName;
+	RegisterNameNode*	newName;
+};
+
+//------------------------------------------------------------------------------
+// PhiNodeRemover<RegisterPressure> -
+
+template <class RegisterPressure>
+struct PhiNodeRemover
+{
+	// Replace the phi nodes by copy instructions.
+	static void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+// Split some of the critical edges and return true if there are still some
+// in the graph after that.
+//
+static bool splitCriticalEdges(ControlGraph& /*cg*/)
+{
+	// FIX: not implemented.
+	return true;
+}
+
+inline void pushName(Pool& pool, RegisterNameNode** stack, SparseSet& pushed, Uint32* nodeListPointer, RegisterName oldName, RegisterName newName)
+{
+	RegisterNameNode& newNode = *new(pool) RegisterNameNode();
+
+	if (pushed.test(oldName))
+		(*stack)->newName = newName;
+	else {
+		newNode.newName = newName;
+		newNode.nextPushed = *nodeListPointer;
+		*nodeListPointer = oldName;
+		newNode.next = *stack;
+		*stack = &newNode;
+		pushed.set(oldName);
+	}
+}
+
+template <class RegisterPressure>
+void PhiNodeRemover<RegisterPressure>::replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	// Initialize the local variables.
+	//
+
+	// When we insert the copies we will also need to create new VirtualRegisters for
+	// the insertion of temporaries. The maximum number of temporary register will not
+	// exceed the number of phiNodes in the primitive graph.
+	Uint32 nameCount = vrManager.getSize();
+	Uint32 maxNameCount = nameCount;
+	for (Uint32 n = 0; n < nNodes; n++)
+		maxNameCount += nodes[n]->getPhiNodes().length();
+
+	// If the CFG contains some critical edges (backward edge which source has more than one
+	// outgoing edge and destination has more than one incomimg edge) then we need the liveness
+	// information to be able to insert temporary copies.
+	RegisterPressure::Set* liveOut = NULL;
+	if (splitCriticalEdges(controlGraph))
+		liveOut = Liveness<LowRegisterPressure>::analysis(controlGraph, nameCount).liveOut;
+
+	DominatorGraph dGraph(controlGraph);
+
+	SparseSet pushed(pool, maxNameCount);
+	SparseSet destinationList(pool, maxNameCount);
+	SparseSet workList(pool, maxNameCount);
+
+	CopyData* copyStats = new(pool) CopyData[maxNameCount];
+	memset(copyStats, '\0', maxNameCount*sizeof(CopyData));
+
+	struct NodeStack {
+		Uint32* next;
+		Uint32* limit;
+		Uint32 pushedList;
+	};
+
+	// Allocate the node stack and initialize the node stack pointer.
+	NodeStack* nodeStack = new(pool) NodeStack[nNodes + 1];
+	NodeStack* nodeStackPtr = nodeStack;
+
+	// We start by the begin node. 
+	Uint32 startNode = 0;
+	Uint32* next = &startNode;
+	Uint32* limit = &startNode + 1;
+
+	while (true) {
+
+		if (next == limit) {
+			// If there are no more node in the sibling, we have to pop the current
+			// frame from the stack and update the copyStats of the pushed nodes.
+			//
+			if (nodeStackPtr == nodeStack)
+				// We are at the bottom of the stack and there are no more nodes
+				// to look at. We are done !
+				break;
+
+			--nodeStackPtr;
+			// We are done with all the children of this node in the dominator tree.
+			// We need to update the copy information of all the new names pushed
+			// during the walk over this node.
+			Uint32 pushedList = nodeStackPtr->pushedList;
+			while (pushedList != 0) {
+				Uint32 nextName = copyStats[pushedList].newName->nextPushed;
+				copyStats[pushedList].newName = copyStats[pushedList].newName->next;
+				pushedList = nextName;
+			}
+
+			// restore the previous frame.
+			next = nodeStackPtr->next;
+			limit = nodeStackPtr->limit;
+		} else {
+			Uint32 currentNode = *next++;
+			Uint32 pushedList = 0;
+
+
+			// Initialize the sets.
+			pushed.clear();
+			destinationList.clear();
+
+			// STEP1:
+			//  Walk the instruction list and to replace all the instruction uses with their new name. 
+			//  If the instruction is a phi node and its defined register is alive at the end of this 
+			//  block then we push the defined register into the stack.
+			//
+			ControlNode& node = *nodes[currentNode];
+			RegisterPressure::Set* currentLiveOut = (liveOut != NULL) ? &liveOut[currentNode] : (RegisterPressure::Set*) 0;
+
+			InstructionList& phiNodes = node.getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& phiNode = phiNodes.get(p);
+
+				InstructionUse* useEnd = phiNode.getInstructionUseEnd();
+				for (InstructionUse* usePtr = phiNode.getInstructionUseBegin(); usePtr < useEnd; usePtr++) {
+					assert(usePtr->isRegister());
+					RegisterName name = usePtr->getRegisterName();
+
+					if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+						usePtr->setRegisterName(copyStats[name].newName->newName);
+				}
+
+				if (currentLiveOut != NULL) {
+					// This is a phi node and we have to push its defined name if it is live
+					// at the end of the node. We only need to do this if the CFG has critical edges.
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd() && phiNode.getInstructionDefineBegin()[0].isRegister());
+					RegisterName name = phiNode.getInstructionDefineBegin()[0].getRegisterName();
+
+					if (currentLiveOut->test(name))
+						pushName(pool, &(copyStats[name].newName), pushed, &pushedList, name, name);
+				}
+				
+			}
+
+			InstructionList& instructions = node.getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+
+						if (copyStats[name].newName != NULL && copyStats[name].newName->newName != name)
+							usePtr->setRegisterName(copyStats[name].newName->newName);
+					}
+			}
+
+			// STEP2:
+			//  Look at this node's successors' phiNodes. We keep track of the number of time
+			//  a VR will be used by another copy instruction and insert each definition into the 
+			//  destinationList. This is the only pass over this node's successors as we will
+			//  get all the information we need in the CopyData structures.
+			//
+			ControlEdge* successorEdgeEnd = node.getSuccessorsEnd();
+			for (ControlEdge* successorEdgePtr = node.getSuccessorsBegin(); successorEdgePtr < successorEdgeEnd; successorEdgePtr++) {
+				Uint32 useIndex = successorEdgePtr->getIndex();
+				ControlNode& successor = successorEdgePtr->getTarget();
+
+				// Look at its phi nodes. The phi nodes are at the top of the instruction list. We exit
+				// as soon as we find an instruction which is not a phi node
+				InstructionList& phiNodes = successor.getPhiNodeInstructions();
+				for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+					Instruction& phiNode = phiNodes.get(p);
+					
+					assert((phiNode.getInstructionUseBegin() + useIndex) < phiNode.getInstructionUseEnd());
+					assert(phiNode.getInstructionDefineBegin() != phiNode.getInstructionDefineEnd());
+
+					InstructionUse& source = phiNode.getInstructionUseBegin()[useIndex];
+					InstructionDefine& destination = phiNode.getInstructionDefineBegin()[0];
+
+					assert(source.isRegister() && destination.isRegister());
+
+					RegisterName sourceName = source.getRegisterName();
+					RegisterName destinationName = destination.getRegisterName();
+
+					// Get the correct name for the source.
+					if (copyStats[sourceName].newName != NULL)
+						sourceName = copyStats[sourceName].newName->newName;
+
+					// Update the CopyData structures.
+					if ((sourceName != rnInvalid) && (sourceName != destinationName)) {
+						copyStats[destinationName].source = sourceName;
+						copyStats[destinationName].classKind = destination.getRegisterClass();
+						copyStats[destinationName].isLiveOut = (currentLiveOut != NULL) ? currentLiveOut->test(destinationName) : false;
+						copyStats[destinationName].sourceNameToUse = destinationName;
+						copyStats[sourceName].sourceNameToUse = sourceName;
+						copyStats[sourceName].useCount++;
+						destinationList.set(destinationName);
+					}
+				}
+			}
+
+			// STEP3:
+			//  Insert into the worklist only the destination registers that will be not used in 
+			//  another copy instruction in this block.
+			//
+			assert(workList.getSize() == 0);
+			for (SparseSet::iterator d = destinationList.begin(); !destinationList.done(d); d = destinationList.advance(d)) {
+				Uint32 dest = destinationList.get(d);
+				if (copyStats[dest].useCount == 0)
+					workList.set(dest);
+			}
+
+			// STEP4:
+			//  Insert the copy instructions.
+			//
+			Uint32 destinationListSize = destinationList.getSize();
+			InstructionList::iterator endOfTheNode = instructions.end();
+
+			// Find the right place to insert the copy instructions.
+			if (destinationListSize != 0)
+				while (instructions.get(endOfTheNode).getFlags() & ifControl)
+					endOfTheNode = instructions.retreat(endOfTheNode);
+
+			while (destinationListSize != 0) {
+				while(workList.getSize()) {
+					RegisterName destinationName = RegisterName(workList.getOne());
+					RegisterName sourceName = copyStats[destinationName].source;
+
+					workList.clear(destinationName);
+					if (copyStats[destinationName].isLiveOut && !copyStats[destinationName].temporaryName) {
+						// Lost copy problem.
+						copyStats[destinationName].isLiveOut = false;
+
+						RegisterName sourceName = destinationName;
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						RegisterName destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].useCount = 0;
+				
+						// We need to insert a copy to a temporary register to keep the
+						// source register valid at the end of the node defining it.
+						// This copy will be inserted right after the phi node defining it.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+						Instruction* definingPhiNode = vrManager.getVirtualRegister(from).getDefiningInstruction();
+						assert(definingPhiNode && (definingPhiNode->getFlags() & ifPhiNode) != 0);
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*definingPhiNode->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						definingPhiNode->getPrimitive()->getContainer()->getInstructions().addFirst(copy);
+
+						copyStats[sourceName].temporaryName = destinationName;
+						copyStats[sourceName].sourceNameToUse = destinationName;
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					}
+
+					// Insert the copy instruction at the end of the current node.
+					RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+					RegisterClassKind classKind = copyStats[destinationName].classKind;
+					RegisterID fromID = buildRegisterID(from, classKind);
+					RegisterID toID = buildRegisterID(destinationName, classKind);
+					Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+					instructions.insertAfter(copy, endOfTheNode);
+					endOfTheNode = instructions.advance(endOfTheNode);
+
+					copyStats[sourceName].useCount = 0;
+					if (destinationList.test(sourceName) && copyStats[sourceName].isLiveOut)
+						pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+
+					if (destinationList.test(sourceName))
+						workList.set(sourceName);
+					destinationList.clear(destinationName);
+				}
+
+				destinationListSize = destinationList.getSize();
+				if (destinationListSize != 0) {
+					RegisterName sourceName = RegisterName(destinationList.getOne());
+					RegisterName destinationName;
+
+					if (!copyStats[sourceName].temporaryName) {
+						// Cycle problem.
+						RegisterClassKind classKind = copyStats[sourceName].classKind;
+						destinationName = getName(vrManager.newVirtualRegister(classKind));
+						assert(destinationName < maxNameCount);
+				
+						copyStats[destinationName].classKind = classKind;
+						copyStats[sourceName].temporaryName = destinationName;
+
+						// Insert the copy instruction at the end of the current node.
+						RegisterName from = copyStats[sourceName].sourceNameToUse;
+
+						RegisterID fromID = buildRegisterID(from, classKind);
+						RegisterID toID = buildRegisterID(destinationName, classKind);
+						Instruction& copy = emitter.newCopy(*vrManager.getVirtualRegister(from).getDefiningInstruction()->getPrimitive(), fromID, toID);
+						vrManager.getVirtualRegister(destinationName).setDefiningInstruction(copy);
+						instructions.insertAfter(copy, endOfTheNode);
+						endOfTheNode = instructions.advance(endOfTheNode);
+					} else 
+						destinationName = copyStats[sourceName].temporaryName;
+
+					copyStats[sourceName].useCount = 0;
+					copyStats[sourceName].isLiveOut = false;
+					copyStats[sourceName].sourceNameToUse = destinationName;
+					pushName(pool, &(copyStats[sourceName].newName), pushed, &pushedList, sourceName, destinationName);
+
+					workList.set(sourceName);
+				}
+			}
+
+			nodeStackPtr->pushedList = pushedList;
+			nodeStackPtr->next = next;
+			nodeStackPtr->limit = limit;
+			++nodeStackPtr;
+			next = dGraph.getSuccessorsBegin(currentNode);
+			limit = dGraph.getSuccessorsEnd(currentNode);
+		}
+	}
+}
+
+#endif // _PHI_NODE_REMOVER_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.cpp

@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocator.h"
+#include "RegisterPressure.h"
+#include "RegisterAllocatorTools.h"
+#include "PhiNodeRemover.h"
+#include "LiveRange.h"
+#include "Liveness.h"
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+#include "Coalescing.h"
+#include "Spilling.h"
+#include "Coloring.h"
+#include "Splits.h"
+
+class Pool;
+class ControlGraph;
+class VirtualRegisterManager;
+class InstructionEmitter;
+
+UT_DEFINE_LOG_MODULE(RegAlloc);
+
+void RegisterAllocator::allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+{
+	// Insert the phi node instructions. We want to do this to have a single defined register per instruction.
+	// If we keep the PhiNode (as a DataNode) and a PhiNode is of DoubleWordKind then we have to execute
+	// some special code for the high word annotation.
+	//
+	RegisterAllocatorTools::insertPhiNodeInstructions(controlGraph, emitter);
+
+	// Perform some tests on the instruction graph.
+	//
+	DEBUG_ONLY(RegisterAllocatorTools::testTheInstructionGraph(controlGraph, vrManager));
+
+	// Replace the phi node instructions by their equivalent copy instructions.
+	//
+	PhiNodeRemover<LowRegisterPressure>::replacePhiNodes(controlGraph, vrManager, emitter);
+
+	// Do the register allocation.
+	//
+	RegisterAllocator registerAllocator(pool, controlGraph, vrManager, emitter);
+	registerAllocator.doGraphColoring();
+}
+
+void RegisterAllocator::doGraphColoring()
+{
+	// Initialize the liverange map.
+	//
+	initLiveRanges();
+
+	// Build the live ranges. We do this to compress the number of RegisterNames 
+	// used in the insterference graph.
+	//
+	LiveRange<LowRegisterPressure>::build(*this);
+
+	// Remove unnecessary copies.
+	//
+	RegisterAllocatorTools::removeUnnecessaryCopies(*this);
+
+	for (Uint8 loop = 0; loop < 10; loop++) {
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********* RegisterAllocator loop %d *********\n", loop));
+
+		while(true) {
+			// Build the interference graph.
+			//
+			iGraph.build();
+
+			// Coalesce the copy instructions.
+			//
+			if (!Coalescing<LowRegisterPressure>::coalesce(*this))
+				break;
+		}
+
+		// Print the interference graph.
+		//
+		DEBUG_LOG_ONLY(iGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Calculate the spill costs.
+		//
+		Spilling<LowRegisterPressure>::calculateSpillCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSpillCosts(*this));
+
+		// Calculate the split costs.
+		//
+		Splits<LowRegisterPressure>::calculateSplitCosts(*this);
+		DEBUG_LOG_ONLY(RegisterAllocatorTools::printSplitCosts(*this));
+
+		// Build the live range graph.
+		//
+		lGraph.build();
+		DEBUG_LOG_ONLY(lGraph.printPretty(UT_LOG_MODULE(RegAlloc)));
+
+		// Color the graph. If it succeeds then we're done with the
+		// register allocation.
+		//
+		if (Coloring<LowRegisterPressure>::color(*this)) {
+			// Write the final colors in the instruction graph.
+			//
+			Coloring<LowRegisterPressure>::finalColoring(*this);
+
+			UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("********** RegisterAllocator  done **********\n"));
+			DEBUG_LOG_ONLY(RegisterAllocatorTools::printInstructions(*this));
+
+			return;
+		}
+
+		// We need to spill some registers.
+		//
+		Spilling<LowRegisterPressure>::insertSpillCode(*this);
+
+		// Insert the split instructions.
+		//
+		Splits<LowRegisterPressure>::insertSplitCode(*this);
+
+		// Update the live ranges.
+		// 
+		// FIX
+	}
+
+#ifdef DEBUG_LOG
+	RegisterAllocatorTools::updateInstructionGraph(*this);
+	RegisterAllocatorTools::printInstructions(*this);
+#endif
+	fprintf(stderr, "!!! Coloring failed after 10 loops !!!\n");
+	abort();
+}
+
+void RegisterAllocator::initLiveRanges()
+{
+	Uint32 count = this->nameCount;
+	RegisterName* name2range = new(pool) RegisterName[nameCount];
+	for (RegisterName r = RegisterName(1); r < count; r = RegisterName(r + 1))
+		name2range[r] = r;
+	this->name2range = name2range;
+	rangeCount = count;
+}

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocator.h

@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_ALLOCATOR_H_
+#define _REGISTER_ALLOCATOR_H_
+
+class Pool;
+class ControlGraph;
+class InstructionEmitter;
+struct SpillCost;
+struct SplitCost;
+
+#include "Liveness.h"
+#include "VirtualRegister.h"
+#include "RegisterPressure.h" // This should included by Backend.cpp
+#include "InterferenceGraph.h"
+#include "LiveRangeGraph.h"
+
+//template <class RegisterPressure>
+class RegisterAllocator
+{
+public:
+
+	Pool&									pool;			//
+	ControlGraph&							controlGraph;	//
+	VirtualRegisterManager&					vrManager;		//
+	InstructionEmitter&						emitter;		//
+
+	RegisterName*							name2range;		//
+	RegisterName*							color;			//
+	SpillCost*								spillCost;		//
+	SparseSet*								willSpill;		//
+	SplitCost*								splitCost;		//
+	NameLinkedList**						splitAround;	//
+	InterferenceGraph<LowRegisterPressure>	iGraph;			//
+	LiveRangeGraph<LowRegisterPressure>		lGraph;			//
+	LivenessInfo<LowRegisterPressure>		liveness;		//
+	Uint32									nameCount;		//
+	Uint32									rangeCount;		//
+	bool									splitFound;		//
+
+private:
+
+	//
+	//
+	void doGraphColoring();
+
+public:
+
+	//
+	//
+	inline RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+
+	//
+	//
+	bool canInterfere(RegisterName /*name1*/, RegisterName /*name2*/) const {return true;}
+
+	//
+	//
+	void initLiveRanges();
+
+	//
+	//
+	static void allocateRegisters(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter);
+};
+
+//
+//
+inline RegisterAllocator::RegisterAllocator(Pool& pool, ControlGraph& controlGraph, VirtualRegisterManager& vrManager, InstructionEmitter& emitter)
+	: pool(pool), controlGraph(controlGraph), vrManager(vrManager), emitter(emitter), iGraph(*this), lGraph(*this), nameCount(vrManager.getSize()) {}
+
+#endif // _REGISTER_ALLOCATOR_H_
+

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.cpp

@@ -0,0 +1,355 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "LogModule.h"
+#include "RegisterAllocatorTools.h"
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Primitives.h"
+#include "InstructionEmitter.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "Spilling.h"
+#include "Splits.h"
+#include "BitSet.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+#ifdef DEBUG
+void RegisterAllocatorTools::testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	// Test the declared VirtualRegisters. The register allocator tries to condense the register universe.
+	// Any gap in the VirtualRegister names will be a loss of efficiency !!!!
+
+	Uint32 nameCount = vrManager.getSize();
+	BitSet registerSeen(controlGraph.pool, nameCount);
+
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					registerSeen.set(usePtr->getRegisterName());
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					registerSeen.set(definePtr->getRegisterName());
+		}
+	}
+
+	bool renameRegisters = false;
+	for (BitSet::iterator i = registerSeen.nextZero(0); !registerSeen.done(i); i = registerSeen.nextZero(i)) {
+		renameRegisters = true;
+		fprintf(stderr, 
+				"WARNING: The VirtualRegister vr%d has been allocated during CodeGeneration but\n"
+				"         is never used nor defined by any instruction in the instruction graph\n"
+				"                                  PLEASE FIX                                  \n",
+				i);
+	}
+	if (renameRegisters) {
+		Instruction** definingInstruction = new Instruction*[nameCount];
+		memset(definingInstruction, '\0', nameCount * sizeof(Instruction*));
+		RegisterName* newName = new RegisterName[nameCount];
+		memset(newName, '\0', nameCount * sizeof(RegisterName));
+		RegisterName nextName = RegisterName(1);
+
+		for (Uint32 n = 0; n < nNodes; n++) {
+
+			InstructionList& instructions = nodes[n]->getInstructions();
+			for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+				Instruction& instruction = instructions.get(i);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+
+			InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+			for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+				Instruction& instruction = phiNodes.get(p);
+
+				InstructionUse* useEnd = instruction.getInstructionUseEnd();
+				for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName name = usePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						usePtr->setRegisterName(newName[name]);
+					}
+
+				InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+				for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+					if (definePtr->isRegister()) {
+						RegisterName name = definePtr->getRegisterName();
+						if (newName[name] == rnInvalid) {
+							newName[name] = nextName;
+							definingInstruction[nextName] = vrManager.getVirtualRegister(name).getDefiningInstruction();
+							nextName = RegisterName(nextName + 1);
+						}
+						definePtr->setRegisterName(newName[name]);
+					}
+			}
+		}
+		
+		vrManager.setSize(nextName);
+
+		for (RegisterName r = RegisterName(1); r < nextName; r = RegisterName(r + 1))
+			vrManager.getVirtualRegister(r).definingInstruction = definingInstruction[r];
+
+		UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("RegisterMap:\n"));
+		for (Uint32 i = 1; i < nameCount; i++)
+			if (newName[i] != 0)
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d becomes vr%d.\n", i, newName[i]));
+			else
+				UT_OBJECTLOG(UT_LOG_MODULE(RegAlloc), PR_LOG_ALWAYS, ("\tvr%d is dead.\n", i));
+
+
+		delete newName;
+		delete definingInstruction;
+	}
+
+}
+#endif // DEBUG
+
+void RegisterAllocatorTools::removeUnnecessaryCopies(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.advance(i);
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(instruction.getInstructionUseBegin() != instruction.getInstructionUseEnd() && instruction.getInstructionUseBegin()[0].isRegister());
+				assert(instruction.getInstructionDefineBegin() != instruction.getInstructionDefineEnd() && instruction.getInstructionDefineBegin()[0].isRegister());
+				
+				RegisterName source = name2range[instruction.getInstructionUseBegin()[0].getRegisterName()];
+				RegisterName destination = name2range[instruction.getInstructionDefineBegin()[0].getRegisterName()];
+
+				if (source == destination)
+					instruction.remove();
+			}
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::updateInstructionGraph(RegisterAllocator& registerAllocator)
+{
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		for (InstructionList::iterator p = phiNodes.begin(); !phiNodes.done(p); p = phiNodes.advance(p)) {
+			Instruction& instruction = phiNodes.get(p);
+
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			for (InstructionUse* usePtr = instruction.getInstructionUseBegin(); usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					usePtr->setRegisterName(name2range[usePtr->getRegisterName()]);
+
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			for (InstructionDefine* definePtr = instruction.getInstructionDefineBegin(); definePtr < defineEnd; definePtr++)
+				if (definePtr->isRegister())
+					definePtr->setRegisterName(name2range[definePtr->getRegisterName()]);
+		}
+	}
+}
+
+
+void RegisterAllocatorTools::insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter)
+{
+	Pool& pool = controlGraph.pool;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+	
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		DoublyLinkedList<PhiNode>& phiNodes = node.getPhiNodes();
+
+		if (!phiNodes.empty()) {
+
+			// Set the index of the incoming edges.
+			Uint32 index = 0;
+			const DoublyLinkedList<ControlEdge>& predecessors = node.getPredecessors();
+			for (DoublyLinkedList<ControlEdge>::iterator p = predecessors.begin(); !predecessors.done(p); p = predecessors.advance(p))
+				predecessors.get(p).setIndex(index++);
+
+			// Insert the phi node instruction in the instruction list.
+			for (DoublyLinkedList<PhiNode>::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				PhiNode& phiNode = phiNodes.get(i);
+				ValueKind kind = phiNode.getKind();
+
+				if (!isStorableKind(kind))
+					continue;
+
+				RegisterClassKind classKind = rckGeneral; // FIX: get class kind from phi node kind.
+				Uint32 nInputs = phiNode.nInputs();
+
+				PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+				emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drLow);
+				for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+					emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drLow);
+
+				node.addPhiNodeInstruction(phiNodeInstruction);
+
+				if (isDoublewordKind(kind)) {
+					PhiNodeInstruction& phiNodeInstruction = *new(pool) PhiNodeInstruction(&phiNode, pool, nInputs);
+
+					emitter.defineProducer(phiNode, phiNodeInstruction, 0, classKind, drHigh);
+					for (Uint32 whichInput = 0; whichInput < nInputs; whichInput++)
+						emitter.useProducer(phiNode.nthInputVariable(whichInput), phiNodeInstruction, whichInput, classKind, drHigh);
+
+					node.addPhiNodeInstruction(phiNodeInstruction);
+				}
+			}
+		}
+	}
+}
+
+#ifdef DEBUG_LOG
+
+void RegisterAllocatorTools::printSpillCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SpillCost* cost = registerAllocator.spillCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Spill costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : ", i));
+		if (cost[i].infinite)
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("infinite\n"));
+		else
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("%f\n", cost[i].cost));
+	}
+}
+
+void RegisterAllocatorTools::printSplitCosts(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	SplitCost* cost = registerAllocator.splitCost;
+
+	UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("Split costs:\n"));
+	for (Uint32 i = 1; i < rangeCount; i++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\trange %d : loads = %f stores = %f\n", i, cost[i].loads, cost[i].stores));
+	}
+}
+
+void RegisterAllocatorTools::printInstructions(RegisterAllocator& registerAllocator)
+{
+	LogModuleObject log = UT_LOG_MODULE(RegAlloc);
+	ControlNode** nodes = registerAllocator.controlGraph.dfsList;
+	Uint32 nNodes = registerAllocator.controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("N%d:\n", n));
+
+		InstructionList& phiNodes = nodes[n]->getPhiNodeInstructions();
+		InstructionList& instructions = nodes[n]->getInstructions();
+
+		if (!phiNodes.empty()) {
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" PhiNodes:\n", n));
+			for(InstructionList::iterator i = phiNodes.begin(); !phiNodes.done(i); i = phiNodes.advance(i)) {
+				phiNodes.get(i).printPretty(log);
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+			}
+			if (!instructions.empty())
+				UT_OBJECTLOG(log, PR_LOG_ALWAYS, (" Instructions:\n", n));
+		}
+
+		for(InstructionList::iterator i = instructions.begin(); !instructions.done(i); i = instructions.advance(i)) {
+			instructions.get(i).printPretty(log);
+			UT_OBJECTLOG(log, PR_LOG_ALWAYS, ("\n"));
+		}
+	}
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/RegisterAllocatorTools.h

@@ -0,0 +1,117 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: RegisterAllocatorTools.h,v 1.1.2.1 1999-03-02 16:12:05 fur%netscape.com Exp $
+//
+
+#ifndef _REGISTER_ALLOCATOR_TOOLS_H_
+#define _REGISTER_ALLOCATOR_TOOLS_H_
+
+#include "LogModule.h"
+#include "RegisterTypes.h"
+#include <string.h>
+
+class RegisterAllocator;
+class ControlGraph;
+class InstructionEmitter;
+class VirtualRegisterManager;
+
+struct RegisterAllocatorTools
+{
+	//
+	//
+	static void insertPhiNodeInstructions(ControlGraph& controlGraph, InstructionEmitter& emitter);
+
+	//
+	//
+	static void updateInstructionGraph(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void removeUnnecessaryCopies(RegisterAllocator& registerAllocator);
+
+#ifdef DEBUG
+	//
+	//
+	static void testTheInstructionGraph(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+#endif // DEBUG
+
+#ifdef DEBUG_LOG
+	//
+	//
+	static void printInstructions(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSpillCosts(RegisterAllocator& registerAllocator);
+
+	//
+	//
+	static void printSplitCosts(RegisterAllocator& registerAllocator);
+#endif // DEBUG_LOG
+};
+
+//
+// FIX: this should go in a class (LookupTable ?)
+//
+
+inline RegisterName findRoot(RegisterName name, RegisterName* table)
+{
+	RegisterName* stack = table;
+	RegisterName* stackPtr = stack;
+
+	RegisterName newName;
+	while((newName = table[name]) != name) {
+		*--stackPtr = name;
+		name = newName;
+	}
+
+	while (stackPtr != stack)
+		table[*stackPtr++] = name;
+
+	return name;
+}
+
+inline void init(RegisterName* table, Uint32 nameCount)
+{
+	for (RegisterName r = RegisterName(0); r < nameCount; r = RegisterName(r + 1))
+		table[r] = r;
+}
+
+inline Uint32 compress(RegisterName* name2range, RegisterName* table, Uint32 nameCount, Uint32 tableSize)
+{
+	RegisterName* liveRange = new RegisterName[tableSize];
+	memset(liveRange, '\0', tableSize * sizeof(RegisterName));
+
+	// Update the lookup table.
+	for (RegisterName r = RegisterName(1); r < tableSize; r = RegisterName(r + 1))
+		findRoot(r, table);
+
+	// Count the liveranges.
+	Uint32 liveRangeCount = 1;
+	for (RegisterName s = RegisterName(1); s < tableSize; s = RegisterName(s + 1))
+		if (table[s] == s)
+			liveRange[s] = RegisterName(liveRangeCount++);
+
+	for (RegisterName t = RegisterName(1); t < nameCount; t = RegisterName(t + 1))
+		name2range[t] = liveRange[table[name2range[t]]];
+
+	return liveRangeCount;
+}
+
+inline double doLog10(Uint32 power)
+{
+	double log = 1.0;
+	while (power--)
+		log *= 10.0;
+	return log;
+}
+
+#endif // _REGISTER_ALLOCATOR_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterAssigner.h

@@ -16,31 +16,23 @@
  * Reserved.
  */
 
-#ifndef __nsIID_h
-#define __nsIID_h
+#ifndef _REGISTER_ASSIGNER_H_
+#define _REGISTER_ASSIGNER_H_
 
-#ifndef nsID_h__
-#include "nsID.h"
-#endif
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
 
-/**
- * An "interface id" which can be used to uniquely identify a given
- * interface.
- */
+class FastBitMatrix;
 
-typedef nsID nsIID;
+class RegisterAssigner
+{
+protected:
+  VirtualRegisterManager& vRegManager;
+  
+public:
+  RegisterAssigner(VirtualRegisterManager& vrMan) : vRegManager(vrMan) {}
+  
+  virtual bool assignRegisters(FastBitMatrix& interferenceMatrix) = 0;
+};
 
-/**
- * A macro shorthand for <tt>const nsIID&<tt>
- */
-
-#define REFNSIID const nsIID&
-
-/**
- * Define an IID (obsolete)
- */
- 
-#define NS_DEFINE_IID(_name, _iidspec) \
-  const nsIID _name = _iidspec
-
-#endif /* __nsIID_h */
+#endif /* _REGISTER_ASSIGNER_H_ */

mozilla/ef/Compiler/RegisterAllocator/RegisterClass.h

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,12 +16,10 @@
  * Reserved.
  */
 
-//
-//	JavaScript.Prefix
-//
-// Global prefix file for the JavaScriptPPC project.
-//
-//
+#ifndef _REGISTER_CLASS_H_
+#define _REGISTER_CLASS_H_
 
-#include "MacPrefix_debug.h"
+#include "Fundamentals.h"
+#include "RegisterTypes.h"
 
+#endif // _REGISTER_CLASS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterPressure.h

@@ -1,5 +1,5 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
  * compliance with the NPL.  You may obtain a copy of the NPL at
@@ -16,16 +16,22 @@
  * Reserved.
  */
 
-#ifndef __nsIServerProvider_h
-#define __nsIServerProvider_h
-#include "nsISupports.h"
+#ifndef _REGISTER_PRESSURE_H_
+#define _REGISTER_PRESSURE_H_
 
-typedef nsID nsSID;
-#define NSSIDREF const nsSID&
+#include "BitSet.h"
+#include "HashSet.h"
 
-class nsIServiceProvider: public nsISupports {
-public:
-  NS_IMETHOD QueryService(NSSIDREF aSID, NSIIDREF sIID, (void **) pService);
+struct LowRegisterPressure
+{
+	typedef BitSet Set;
+	static const bool setIsOrdered = true;
 };
 
-#endif /* __nsIServerProvider_h */
+struct HighRegisterPressure
+{
+	typedef HashSet Set;
+	static const bool setIsOrdered = false;
+};
+
+#endif // _REGISTER_PRESSURE_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterTypes.h

@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _REGISTER_TYPES_H_
+#define _REGISTER_TYPES_H_
+
+#include "Fundamentals.h"
+
+//------------------------------------------------------------------------------
+// RegisterName -
+//
+
+enum RegisterName {
+	rnInvalid = 0,
+};
+
+//------------------------------------------------------------------------------
+// RegisterClassKind -
+//
+
+enum RegisterClassKind {
+	rckInvalid = 0,
+	rckGeneral,
+	rckStackSlot,
+
+	nRegisterClassKind
+};
+
+//------------------------------------------------------------------------------
+// RegisterID -
+//
+
+enum RegisterID {
+	invalidID = 0
+};
+
+//------------------------------------------------------------------------------
+// RegisterKind -
+//
+
+enum RegisterKind {
+	rkCallerSave = 0,
+	rkCalleeSave,
+};
+
+struct NameLinkedList {
+	RegisterName name;
+	NameLinkedList* next;
+};
+
+#ifdef DEBUG
+
+const registerNameMask = 		0x03ffffff;
+const coloredRegisterMask = 	0x04000000;
+const machineRegisterMask = 	0x08000000;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const coloredRegisterShift = 	26;
+const machineRegisterShift = 	27;
+const registerClassShift = 		28;
+
+#else // DEBUG
+
+const registerNameMask = 		0x0fffffff;
+const registerClassMask = 		0xf0000000;
+
+const registerNameShift = 		0;
+const registerClassShift = 		28;
+
+#endif // DEBUG
+
+
+inline RegisterClassKind getClass(RegisterID registerID) {return RegisterClassKind((registerID & registerClassMask) >> registerClassShift);}
+inline RegisterName getName(RegisterID registerID) {return RegisterName((registerID & registerNameMask) >> registerNameShift);}
+inline void setClass(RegisterID& registerID, RegisterClassKind classKind) {registerID = RegisterID((registerID & ~registerClassMask) | ((classKind << registerClassShift) & registerClassMask));}
+inline void setName(RegisterID& registerID, RegisterName name) {assert((name & ~registerNameMask) == 0); registerID = RegisterID((registerID & ~registerNameMask) | ((name << registerNameShift) & registerNameMask));}
+inline RegisterID buildRegisterID(RegisterName name, RegisterClassKind classKind) {return RegisterID(((classKind << registerClassShift) & registerClassMask) | ((name << registerNameShift) & registerNameMask));}
+
+#ifdef DEBUG
+
+inline bool isMachineRegister(RegisterID rid) {return (rid & machineRegisterMask) != 0;}
+inline void setMachineRegister(RegisterID& rid) {rid = RegisterID(rid | machineRegisterMask);}
+inline bool isColoredRegister(RegisterID rid) {return (rid & coloredRegisterMask) != 0;}
+inline void setColoredRegister(RegisterID& rid) {rid = RegisterID(rid | coloredRegisterMask);}
+
+#endif // DEBUG
+
+#endif // _REGISTER_TYPES_H_

mozilla/ef/Compiler/RegisterAllocator/SSATools.cpp

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,6 +16,17 @@
  * Reserved.
  */
 
-/* Nothing to do here. Add xpcom-specific defines here if necessary */
+#include "Fundamentals.h"
+#include "SSATools.h"
+#include "ControlGraph.h"
+#include "VirtualRegister.h"
+#include "Liveness.h"
 
-#define _IMPL_NS_COM 1
+void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	if (!controlGraph.hasBackEdges)
+		return;
+
+	Liveness liveness(controlGraph.pool);
+	liveness.buildLivenessAnalysis(controlGraph, vrManager);
+}

mozilla/ef/Compiler/RegisterAllocator/SSATools.h

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,12 +16,14 @@
  * Reserved.
  */
 
-//
-//	JavaScript.Prefix
-//
-// Global prefix file for the JavaScriptPPC project.
-//
-//
+#ifndef _SSA_TOOLS_H_
+#define _SSA_TOOLS_H_
 
-#include "MacPrefix.h"
+#include "Fundamentals.h"
 
+class ControlGraph;
+class VirtualRegisterManager;
+
+extern void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager);
+
+#endif // _SSA_TOOLS_H_

mozilla/ef/Compiler/RegisterAllocator/SparseSet.cpp

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  *
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
@@ -16,12 +16,22 @@
  * Reserved.
  */
 
-//
-//	xpcom.Prefix
-//
-// Global prefix file for the xpcom project.
-//
-//
+#include "Fundamentals.h"
+#include "SparseSet.h"
+#include "BitSet.h"
+#include "Pool.h"
 
-#include "MacPrefix.h"
-#include "xpcomConfig.h"
+#ifdef DEBUG_LOG
+// Print the set.
+//
+void SparseSet::printPretty(LogModuleObject log)
+{
+	Pool pool;
+	BitSet set(pool, universeSize);
+
+	for (Uint32 i = 0; i < count; i++)
+	   set.set(node[i].element);
+
+	set.printPretty(log);
+}
+#endif // DEBUG_LOG

mozilla/ef/Compiler/RegisterAllocator/SparseSet.h

@@ -0,0 +1,168 @@
+//	-*- mode:C++; tab-width:4; truncate-lines:t -*-
+//
+//           CONFIDENTIAL AND PROPRIETARY SOURCE CODE OF
+//              NETSCAPE COMMUNICATIONS CORPORATION
+// Copyright © 1996, 1997 Netscape Communications Corporation.  All Rights
+// Reserved.  Use of this Source Code is subject to the terms of the
+// applicable license agreement from Netscape Communications Corporation.
+// The copyright notice(s) in this Source Code does not indicate actual or
+// intended publication of this Source Code.
+//
+// $Id: SparseSet.h,v 1.1.2.1 1999-03-02 16:12:07 fur%netscape.com Exp $
+//
+
+#ifndef _SPARSE_SET_H_
+#define _SPARSE_SET_H_
+
+#include "Fundamentals.h"
+#include "Pool.h"
+#include "LogModule.h"
+#include "BitSet.h"
+
+class SparseSet
+{
+private:
+
+	struct Node {
+		Uint32		element;
+		Uint32		stackIndex;
+	};
+
+	Node*			node;
+	Uint32			count;
+	Uint32			universeSize;
+
+private:
+
+	// No copy constructor.
+	SparseSet(const SparseSet&);
+
+	// Check if the given set's universe is of the same size than this universe.
+	void checkUniverseCompatibility(const SparseSet& set) const {assert(set.universeSize == universeSize);}
+	// Check if pos is valid for this set's universe.
+	void checkMember(Int32 pos) const {assert(pos >=0 && Uint32(pos) < universeSize);}
+
+public:
+
+	SparseSet(Pool& pool, Uint32 universeSize) : universeSize(universeSize) {node = new(pool) Node[universeSize]; clear();}
+
+	// Clear the sparse set.
+	void clear() {count = 0;}
+	// Clear the element at index.
+	inline void clear(Uint32 index);
+	// Set the element at index.
+	inline void set(Uint32 index);
+	// Return true if the element at index is set.
+	inline bool test(Uint32 index) const;
+	// Union with the given sparse set.
+	inline void or(const SparseSet& set);
+	// Intersection with the given sparse set.
+	inline void and(const SparseSet& set);
+	// Difference with the given sparse set.
+	inline void difference(const SparseSet& set);
+	// Copy set.
+	inline SparseSet& operator = (const SparseSet& set);
+	inline SparseSet& operator = (const BitSet& set);
+	// Return true if the sparse sets are identical.
+	friend bool operator == (const SparseSet& set1, const SparseSet& set2);
+	// Return true if the sparse sets are different.
+	friend bool operator != (const SparseSet& set1, const SparseSet& set2);
+
+	// Logical operators.
+	SparseSet& operator |= (const SparseSet& set) {or(set); return *this;}
+	SparseSet& operator &= (const SparseSet& set) {and(set); return *this;}
+	SparseSet& operator -= (const SparseSet& set) {difference(set); return *this;}
+
+	// Iterator to conform with the set API.
+	typedef Int32 iterator;
+	// Return the iterator for the first element of this set.
+	iterator begin() const {return count - 1;}
+	// Return the next iterator.
+	iterator advance(iterator pos) const {return --pos;}
+	// Return true if the iterator is at the end of the set.
+	bool done(iterator pos) const {return pos < 0;}
+	// Return the element for the given iterator;
+	Uint32 get(iterator pos) const {return node[pos].element;}
+	// Return one element of this set.
+	Uint32 getOne() const {assert(count > 0); return node[0].element;}
+	// Return the size of this set.
+	Uint32 getSize() const {return count;}
+
+#ifdef DEBUG_LOG
+	// Print the set.
+	void printPretty(LogModuleObject log);
+#endif // DEBUG_LOG
+};
+
+inline void SparseSet::clear(Uint32 element)
+{
+	checkMember(element);
+	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex < count) && (node[stackIndex].element == element)) {
+		Uint32 stackTop = node[count - 1].element;
+
+		node[stackIndex].element = stackTop;
+		node[stackTop].stackIndex = stackIndex;
+		this->count = count - 1;
+	}
+}
+
+inline void SparseSet::set(Uint32 element)
+{
+	checkMember(element);
+  	Uint32 count = this->count;
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+
+	if ((stackIndex >= count) || (node[stackIndex].element != element)) {
+		node[count].element = element;
+		node[element].stackIndex = count;
+		this->count = count + 1;
+	}
+}
+
+inline bool SparseSet::test(Uint32 element) const
+{
+	checkMember(element);
+	Node* node = this->node;
+
+	Uint32 stackIndex = node[element].stackIndex;
+	return ((stackIndex < count) && (node[stackIndex].element == element));
+}
+
+inline SparseSet& SparseSet::operator = (const SparseSet& set)
+{
+	checkUniverseCompatibility(set);
+	Uint32 sourceCount = set.getSize();
+	Node* node = this->node;
+
+	memcpy(node, set.node, sourceCount * sizeof(Node));
+
+	for (Uint32 i = 0; i < sourceCount; i++) {
+		Uint32 element = node[i].element;
+		node[element].stackIndex = i;
+	}
+
+	count = sourceCount;
+
+	return *this;
+}
+
+
+inline SparseSet& SparseSet::operator = (const BitSet& set)
+{
+	// FIX: there's room for optimization here.
+	assert(universeSize == set.getSize());
+
+	clear();
+	for (Int32 i = set.firstOne(); i != -1; i = set.nextOne(i))
+		this->set(i);
+	return *this;
+}
+
+#endif // _SPARSE_SET_H_

mozilla/ef/Compiler/RegisterAllocator/Spilling.cpp

@@ -0,0 +1,270 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef NEW_LAURENTM_CODE
+#define INCLUDE_EMITTER
+#include "CpuInfo.h"
+#include "Fundamentals.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "InstructionEmitter.h"
+#include "Spilling.h"
+
+
+void Spilling::
+insertSpillCode(ControlNode** dfsList, Uint32 nNodes)
+{
+  PRUint32 nVirtualRegisters = vRegManager.count();
+  FastBitSet currentLive(vRegManager.pool, nVirtualRegisters);
+  FastBitSet usedInThisInstruction(vRegManager.pool, nVirtualRegisters);
+  RegisterFifo grNeedLoad(nVirtualRegisters);
+  RegisterFifo fpNeedLoad(nVirtualRegisters);
+
+  for (PRInt32 n = nNodes - 1; n >= 0; n--)
+	{
+	  PR_ASSERT(grNeedLoad.empty() & fpNeedLoad.empty());
+	  ControlNode& node = *dfsList[n];
+
+	  currentLive = node.liveAtEnd;
+
+	  PRUint32 nGeneralAlive = 0;
+	  PRUint32 nFloatingPointAlive = 0;
+
+	  // Get the number of registers alive at the end of this node.
+	  for (PRInt32 j = currentLive.firstOne(); j != -1; j = currentLive.nextOne(j))
+		{
+		  VirtualRegister& vReg = vRegManager.getVirtualRegister(j);
+		  if (vReg.spillInfo.willSpill)
+			{
+			  currentLive.clear(j);
+			}
+		  else
+			{
+			  switch (vReg.getClass())
+				{
+				case vrcInteger:
+				  nGeneralAlive++;
+				  break;
+				case vrcFloatingPoint:
+				case vrcFixedPoint:
+				  nFloatingPointAlive++;
+				  break;
+				default:
+				  break;
+				}
+			}
+		}
+	  
+//		  if(node.dfsNum == 8) printf("\n________Begin Node %d________\n", node.dfsNum);
+
+		InstructionList& instructions = node.getInstructions();
+	  for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i))
+		{
+		  Instruction&       instruction = instructions.get(i);
+		  InstructionUse*    useBegin    = instruction.getInstructionUseBegin();
+		  InstructionUse*    useEnd      = instruction.getInstructionUseEnd();
+		  InstructionUse*    usePtr;
+		  InstructionDefine* defBegin    = instruction.getInstructionDefineBegin();
+		  InstructionDefine* defEnd      = instruction.getInstructionDefineEnd();
+		  InstructionDefine* defPtr;
+
+//		if(node.dfsNum == 8)  { printf("\n");
+//		instruction.printPretty(stdout);
+//		printf("\n"); }
+
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				currentLive.clear(vReg.getRegisterIndex());
+				switch (vReg.getClass())
+				  {
+				  case vrcInteger:
+					nGeneralAlive--;
+					break;
+				  case vrcFloatingPoint:
+				  case vrcFixedPoint:
+					nFloatingPointAlive--;
+					break;
+				  default:
+					break;
+				  }
+			  }
+
+		  // Check for deaths
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				if (!currentLive.test(vReg.getRegisterIndex()))
+				  // This is the last use of this register.
+				  {
+					currentLive.set(vReg.getRegisterIndex());
+					switch (vReg.getClass())
+					  {
+					  case vrcInteger:
+						nGeneralAlive++;
+						while (/*(nGeneralAlive > NUMBER_OF_GREGISTERS) &&*/ !grNeedLoad.empty())
+						  {
+							PRUint32 toLoad = grNeedLoad.get();
+							currentLive.clear(toLoad);
+							nGeneralAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  case vrcFloatingPoint:
+					  case vrcFixedPoint:
+						nFloatingPointAlive++;
+						while (/*(nFloatingPointAlive > NUMBER_OF_FPREGISTERS) &&*/ !fpNeedLoad.empty())
+						  {
+							PRUint32 toLoad = fpNeedLoad.get();
+							currentLive.clear(toLoad);
+							nFloatingPointAlive--;
+							
+							VirtualRegister& nReg = vRegManager.getVirtualRegister(toLoad);
+							Instruction& lastUsingInstruction = *nReg.spillInfo.lastUsingInstruction;
+							emitter.emitLoadAfter(*lastUsingInstruction.getPrimitive(), lastUsingInstruction.getLinks().prev,
+												  nReg.getAlias(), *nReg.equivalentRegister[vrcStackSlot]);
+							nReg.releaseSelf();
+						  }
+						break;
+					  default:
+						break;
+					  }
+				  }
+			  }
+
+		  // Handle uses
+		  for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+			if (usePtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = usePtr->getVirtualRegister();
+				PRUint32 registerIndex = vReg.getRegisterIndex();
+
+				if (vReg.spillInfo.willSpill) {
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchUseToSpill((usePtr - useBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  switch (vReg.getClass())
+						{
+						case vrcInteger:
+						  if (!grNeedLoad.test(registerIndex))
+							{
+							  grNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vrcInteger);
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /* if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						case vrcFloatingPoint:
+						case vrcFixedPoint:
+						  if (!fpNeedLoad.test(registerIndex))
+							{
+							  fpNeedLoad.put(registerIndex);
+							  VirtualRegister& alias = vRegManager.newVirtualRegister(vReg.getClass());
+							  if (vReg.isPreColored())
+								  alias.preColorRegister(vReg.getPreColor());
+							  /*if (vReg.hasSpecialInterference) {
+								  alias.specialInterference.sizeTo(NUMBER_OF_REGISTERS);
+								  alias.specialInterference = vReg.specialInterference;
+								  alias.hasSpecialInterference = true;
+							  } */
+							  vReg.setAlias(alias);
+							  vReg.retainSelf();
+							}
+						  break;
+						default:
+						  break;
+						}
+					  usePtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+					  usedInThisInstruction.set(registerIndex);
+					  vReg.spillInfo.lastUsingInstruction = &instruction;
+					}
+				  currentLive.clear(registerIndex);
+				} else { // will not spill
+				  currentLive.set(registerIndex);
+				}
+			  }
+		  
+		  // Handle definitions
+		  for (defPtr = defBegin; defPtr < defEnd; defPtr++)
+			if (defPtr->isVirtualRegister())
+			  {
+				VirtualRegister& vReg = defPtr->getVirtualRegister();
+				
+				if (vReg.spillInfo.willSpill)
+#if defined(GENERATE_FOR_X86)
+				  if (!instruction.switchDefineToSpill((defPtr - defBegin), *vReg.equivalentRegister[vrcStackSlot]))
+#endif
+					{
+					  if (usedInThisInstruction.test(vReg.getRegisterIndex()))
+						// this virtualRegister was used in this instruction and is also defined. We need to move 
+						// this virtual register to its alias first and then save it to memory.
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg.getAlias(), *vReg.equivalentRegister[vrcStackSlot]);
+						  defPtr->getVirtualRegisterPtr().initialize(vReg.getAlias());
+						}
+					  else
+						{
+						  emitter.emitStoreAfter(*instruction.getPrimitive(), &instruction.getLinks(), 
+												 vReg, *vReg.equivalentRegister[vrcStackSlot]);
+						}
+					}
+			  }
+		}
+	  while (!grNeedLoad.empty())
+		{
+		  PRUint32 nl = grNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+		  
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+	  while (!fpNeedLoad.empty())
+		{
+		  PRUint32 nl = fpNeedLoad.get();
+		  VirtualRegister& nlReg = vRegManager.getVirtualRegister(nl);
+		  Instruction& lastUse = *nlReg.spillInfo.lastUsingInstruction;
+
+		  emitter.emitLoadAfter(*lastUse.getPrimitive(), lastUse.getLinks().prev, 
+								nlReg.getAlias(), *nlReg.equivalentRegister[vrcStackSlot]);
+		  nlReg.releaseSelf();
+		}
+
+//	  if(node.dfsNum == 8) printf("\n________End Node %d________\n", node.dfsNum);
+
+	}
+}
+#endif

mozilla/ef/Compiler/RegisterAllocator/Spilling.h

@@ -0,0 +1,269 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPILLING_H_
+#define _SPILLING_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "SparseSet.h"
+
+template <class RegisterPressure>
+class Spilling
+{
+private:
+	static void insertStoreAfter(Instruction& instruction, RegisterName name);
+	static void insertLoadBefore(Instruction& instruction, RegisterName name);
+
+public:
+	static void calculateSpillCosts(RegisterAllocator& registerAllocator);
+	static void insertSpillCode(RegisterAllocator& registerAllocator);
+};
+
+struct SpillCost
+{
+	double loads;
+	double stores;
+	double copies;
+	double cost;
+	bool infinite;
+};
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertSpillCode(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet currentLive(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+	SparseSet& willSpill = *registerAllocator.willSpill;
+	
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+
+		needLoad.clear();
+		currentLive = liveOut[n];
+		mustSpill = currentLive;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i);) {
+			Instruction& instruction = instructions.get(i);
+			i = instructions.retreat(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			bool foundLiveDefine = false;
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					if (currentLive.test(name2range[definePtr->getRegisterName()])) {
+						foundLiveDefine = true;
+						break;
+					}
+				} else {
+					foundLiveDefine = true;
+					break;
+				}
+			if (defineBegin != defineEnd && !foundLiveDefine) {
+				fprintf(stderr, "!!! Removed instruction because it was only defining unused registers !!!\n");
+				instruction.remove();
+			}
+
+ 			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+#ifdef DEBUG
+					if (needLoad.test(range))
+						if (!mustSpill.test(range) && registerAllocator.spillCost[range].infinite && willSpill.test(range)) {
+							fprintf(stderr, "Tried to spill a register with infinite spill cost\n");
+							abort();
+						}
+#endif // DEBUG
+					if (willSpill.test(range))
+						insertStoreAfter(instruction, range);
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister()) {
+						RegisterName range = name2range[usePtr->getRegisterName()];
+						if (!currentLive.test(range))
+							for (SparseSet::iterator r = needLoad.begin(); !needLoad.done(r); r = needLoad.advance(r)) {
+								RegisterName load = RegisterName(needLoad.get(r));
+								if (willSpill.test(load))
+									insertLoadBefore(instruction, load);
+								mustSpill.set(load);
+							}
+						needLoad.clear();
+					}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					currentLive.clear(name2range[definePtr->getRegisterName()]);
+
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					currentLive.set(range);
+					needLoad.set(range);
+				}
+		}
+
+		for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+			RegisterName load = RegisterName(needLoad.get(l));
+			if (willSpill.test(load))
+				insertLoadBefore(instructions.first(), load);
+		}		
+	}
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertLoadBefore(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert load for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::insertStoreAfter(Instruction& /*instruction*/, RegisterName name)
+{
+	fprintf(stdout, "will insert store for range %d\n", name);
+}
+
+template <class RegisterPressure>
+void Spilling<RegisterPressure>::calculateSpillCosts(RegisterAllocator& registerAllocator)
+{
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	Pool& pool = registerAllocator.pool;
+	SparseSet live(pool, rangeCount);
+	SparseSet needLoad(pool, rangeCount);
+	SparseSet mustSpill(pool, rangeCount);
+
+	SparseSet alreadyStored(pool, rangeCount); // FIX: should get this from previous spilling.
+
+	SpillCost* cost = new SpillCost[rangeCount];
+	memset(cost, '\0', rangeCount * sizeof(SpillCost));
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+
+		double weight = doLog10(node.loopDepth);
+
+		needLoad.clear();
+		live = liveOut[n];
+		mustSpill = live;
+
+		InstructionList& instructions = nodes[n]->getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister()) {
+					RegisterName range = name2range[definePtr->getRegisterName()];
+
+					if (needLoad.test(range))
+						if (!mustSpill.test(range))
+							cost[range].infinite = true;
+
+					if ((false /* !rematerializable(range) */ || !needLoad.test(range)) && !alreadyStored.test(range))
+						cost[range].stores += weight;
+
+					needLoad.clear(range);
+				}
+
+			if (instruction.getFlags() & ifCopy)
+				for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+					if (usePtr->isRegister())
+						if (!live.test(name2range[usePtr->getRegisterName()])) {
+							for (SparseSet::iterator l = needLoad.begin(); !needLoad.done(l); l = needLoad.advance(l)) {
+								Uint32 range = needLoad.get(l);
+								cost[range].loads += weight;
+								mustSpill.set(range);
+							}
+							needLoad.clear();
+						}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+
+					live.set(range);
+					needLoad.set(range);
+				}
+
+			if (instruction.getFlags() & ifCopy) {
+				assert(useBegin != useEnd && useBegin[0].isRegister());
+				assert(defineBegin != defineEnd && defineBegin[0].isRegister());
+
+				RegisterName source = name2range[useBegin[0].getRegisterName()];
+				RegisterName destination = name2range[defineBegin[0].getRegisterName()];
+
+				cost[source].copies += weight;
+				cost[destination].copies += weight;
+			}			
+		}
+
+		for (SparseSet::iterator s = needLoad.begin(); !needLoad.done(s); s = needLoad.advance(s))
+			cost[needLoad.get(s)].loads += weight;
+	}
+	
+	for (Uint32 r = 0; r < rangeCount; r++) {
+		SpillCost& c = cost[r];
+		c.cost = 2 * (c.loads + c.stores) - c.copies;
+	}
+
+	registerAllocator.spillCost = cost;
+}
+
+#endif // _SPILLING_H_

mozilla/ef/Compiler/RegisterAllocator/Splits.h

@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _SPLITS_H_
+#define _SPLITS_H_
+
+#include "Fundamentals.h"
+#include <string.h>
+#include "Pool.h"
+#include "ControlGraph.h"
+#include "ControlNodes.h"
+#include "Instruction.h"
+#include "RegisterAllocator.h"
+#include "RegisterAllocatorTools.h"
+
+UT_EXTERN_LOG_MODULE(RegAlloc);
+
+template <class RegisterPressure>
+struct Splits
+{
+	static void calculateSplitCosts(RegisterAllocator& registerAllocator);
+	static bool findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range);
+	static void insertSplitCode(RegisterAllocator& registerAllocator);
+};
+
+struct SplitCost
+{
+	double loads;
+	double stores;
+};
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::insertSplitCode(RegisterAllocator& /*registerAllocator*/)
+{
+	// FIX
+}
+
+template <class RegisterPressure>
+bool Splits<RegisterPressure>::findSplit(RegisterAllocator& registerAllocator, RegisterName* color, RegisterName range)
+{
+	Pool& pool = registerAllocator.pool;
+	NameLinkedList** neighborsWithColor = new(pool) NameLinkedList*[6]; // FIX
+	memset(neighborsWithColor, '\0', 6 * sizeof(NameLinkedList*));
+
+	InterferenceGraph<RegisterPressure>& iGraph = registerAllocator.iGraph;
+
+	for (InterferenceVector* vector = iGraph.getInterferenceVector(range); vector != NULL; vector = vector->next)
+		for (Int32 i = vector->count - 1; i >=0; --i) {
+			RegisterName neighbor = vector->neighbors[i];
+			RegisterName c = color[neighbor];
+
+			if (c < 6) { // FIX
+				NameLinkedList* node = new(pool) NameLinkedList();
+				node->name = neighbor;
+				node->next = neighborsWithColor[c];
+				neighborsWithColor[c] = node;
+			}
+		}
+
+	bool splitAroundName = true;
+
+	LiveRangeGraph<RegisterPressure>& lGraph = registerAllocator.lGraph;
+	RegisterName bestColor = RegisterName(6); // FIX
+	double bestCost = registerAllocator.spillCost[range].cost;
+	SplitCost* splitCost = registerAllocator.splitCost;
+
+	for (RegisterName i = RegisterName(0); i < 6; i = RegisterName(i + 1)) { // FIX
+
+		double splitAroundNameCost = 0.0;
+		bool canSplitAroundName = true;
+
+		SplitCost& sCost = splitCost[range];
+		double addedCost = 2.0 * (sCost.stores + sCost.loads);
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(neighbor, range)) {
+				canSplitAroundName = false;
+				break;
+			} else
+				splitAroundNameCost += addedCost;
+		}
+		if (canSplitAroundName && splitAroundNameCost < bestCost) {
+			bestCost = splitAroundNameCost;
+			bestColor = i;
+			splitAroundName = true;
+		}
+
+		double splitAroundColorCost = 0.0;
+		bool canSplitAroundColor = true;
+
+		for (NameLinkedList* node = neighborsWithColor[i]; node != NULL; node = node->next) {
+			RegisterName neighbor = node->name;
+			if (lGraph.haveEdge(range, neighbor)) {
+				canSplitAroundColor = false;
+				break;
+			} else {
+				SplitCost& sCost = splitCost[neighbor];
+				double addedCost = 2.0 * (sCost.stores + sCost.loads);
+				splitAroundColorCost += addedCost;
+			}
+		}
+		if (canSplitAroundColor && splitAroundColorCost < bestCost) {
+			bestCost = splitAroundColorCost;
+			bestColor = i;
+			splitAroundName = false;
+		}
+ 	}
+	if (bestColor < RegisterName(6)) {
+		color[range] = bestColor;
+		registerAllocator.splitFound = true;
+
+		NameLinkedList** splitAround = registerAllocator.splitAround;
+
+		if (splitAroundName)
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				newNode->name = node->name;
+				newNode->next = splitAround[range];
+				splitAround[range] = newNode;
+			}
+		else
+			for (NameLinkedList* node = neighborsWithColor[bestColor]; node != NULL; node = node->next) {
+				NameLinkedList* newNode = new(pool) NameLinkedList();
+				RegisterName neighbor = node->name;
+				newNode->name = range;
+				newNode->next = splitAround[neighbor];
+				splitAround[neighbor] = newNode;
+			}
+
+		trespass("Found a split");
+		return true;
+	}
+
+	return false;
+}
+
+template <class RegisterPressure>
+void Splits<RegisterPressure>::calculateSplitCosts(RegisterAllocator& registerAllocator)
+{
+	Pool& pool = registerAllocator.pool;
+	Uint32 rangeCount = registerAllocator.rangeCount;
+	RegisterName* name2range = registerAllocator.name2range;
+
+	SplitCost* splitCost = new(pool) SplitCost[rangeCount];
+	memset(splitCost, '\0', rangeCount * sizeof(SplitCost));
+
+	SparseSet live(pool, rangeCount);
+	RegisterPressure::Set* liveIn = registerAllocator.liveness.liveIn;
+	RegisterPressure::Set* liveOut = registerAllocator.liveness.liveOut;
+
+	ControlGraph& controlGraph = registerAllocator.controlGraph;
+	ControlNode** nodes = controlGraph.dfsList;
+	Uint32 nNodes = controlGraph.nNodes;
+
+	for (Uint32 n = 0; n < nNodes; n++) {
+		ControlNode& node = *nodes[n];
+		double weight = doLog10(node.loopDepth);
+
+		live = liveOut[n];
+
+		ControlEdge* successorsEnd = node.getSuccessorsEnd();
+		for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++) {
+			ControlNode& successor = successorsPtr->getTarget();
+
+			if (successor.getControlKind() != ckEnd) {
+				RegisterPressure::Set& successorLiveIn = liveIn[successor.dfsNum];
+
+				for (SparseSet::iterator i = live.begin(); !live.done(i); i = live.advance(i)) {
+					RegisterName name = RegisterName(live.get(i));
+					if (!successorLiveIn.test(name))
+						splitCost[name].loads += doLog10(successor.loopDepth);
+				}
+			}
+		}
+
+		InstructionList& instructions = node.getInstructions();
+		for (InstructionList::iterator i = instructions.end(); !instructions.done(i); i = instructions.retreat(i)) {
+			Instruction& instruction = instructions.get(i);
+
+			InstructionUse* useBegin = instruction.getInstructionUseBegin();
+			InstructionUse* useEnd = instruction.getInstructionUseEnd();
+			InstructionUse* usePtr;
+			InstructionDefine* defineBegin = instruction.getInstructionDefineBegin();
+			InstructionDefine* defineEnd = instruction.getInstructionDefineEnd();
+			InstructionDefine* definePtr;
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					splitCost[name2range[definePtr->getRegisterName()]].stores += weight;
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister()) {
+					RegisterName range = name2range[usePtr->getRegisterName()];
+					if (!live.test(range)) {
+						if (&instruction != &instructions.last())
+							splitCost[range].loads += weight;
+						else {
+							ControlEdge* successorsEnd = node.getSuccessorsEnd();
+							for (ControlEdge* successorsPtr = node.getSuccessorsBegin(); successorsPtr < successorsEnd; successorsPtr++)
+								splitCost[range].loads += doLog10(successorsPtr->getTarget().loopDepth);
+						}
+					}
+				}
+
+			for (definePtr = defineBegin; definePtr < defineEnd; definePtr++) 
+				if (definePtr->isRegister())
+					live.clear(name2range[definePtr->getRegisterName()]);
+
+			for (usePtr = useBegin; usePtr < useEnd; usePtr++)
+				if (usePtr->isRegister())
+					live.set(name2range[usePtr->getRegisterName()]);
+		}
+	}
+
+	NameLinkedList** splitAround = new(pool) NameLinkedList*[rangeCount];
+	memset(splitAround, '\0', rangeCount * sizeof(NameLinkedList*));
+	registerAllocator.splitAround = splitAround;
+
+	registerAllocator.splitCost = splitCost;
+	registerAllocator.splitFound = false;
+}
+
+#endif // _SPLITS_H_

mozilla/ef/Compiler/RegisterAllocator/Timer.cpp

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "Timer.h"
+#include "Pool.h"
+
+static Pool pool;											// Pool for the Timer class.
+static HashTable<TimerEntry*> timerEntries(pool);			// Timers hashtable.
+
+const nTimersInABlock = 128;								// Number of timers in a block.
+static PRTime *timers = new(pool) PRTime[nTimersInABlock];	// A block of timers.
+static Uint8 nextTimer = 0;									// nextAvailableTimer.
+
+//
+// Calibrate the call to PR_Now().
+//
+static PRTime calibrate()
+{
+	PRTime t = PR_Now();
+	PRTime& a = *new(pool) PRTime();
+
+	// Call 10 times the PR_Now() function.
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); a = PR_Now(); 
+	t = (PR_Now() - t + 9) / 10;
+
+	return t;
+}
+
+static PRTime adjust = calibrate();
+
+//
+// Return the named timer..
+//
+TimerEntry& Timer::getTimerEntry(const char* name)
+{
+	if (!timerEntries.exists(name)) {
+		TimerEntry* newEntry = new(pool) TimerEntry();
+		newEntry->accumulator = 0;
+		newEntry->running = false;
+		timerEntries.add(name, newEntry);
+	}
+
+	return *timerEntries[name];
+}
+
+//
+// Return a reference to a new timer.
+//
+PRTime& Timer::getNewTimer()
+{
+	if (nextTimer >= nTimersInABlock) {
+		timers = new(pool) PRTime[nTimersInABlock];
+		nextTimer = 0;
+	}
+	return timers[nextTimer++];
+}
+
+static Uint32 timersAreFrozen = 0;
+
+//
+// Start the named timer.
+//
+void Timer::start(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(!timer.running);
+
+	timer.accumulator = 0;
+	timer.running = true;
+	timer.done = false;
+
+	unfreezeTimers();
+}
+
+//
+// Stop the named timer.
+//
+void Timer::stop(const char* name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+	PR_ASSERT(timer.running);
+	timer.running = false;
+	timer.done = true;
+
+	unfreezeTimers();
+}
+
+//
+// Freeze all the running timers.
+//
+void Timer::freezeTimers()
+{
+	PRTime when = PR_Now() - adjust;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry*> entries = timerEntries;
+		Uint32 count = entries.size();
+
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.accumulator += (when - *entry.startTime);
+			}
+		}
+	}
+	timersAreFrozen++;
+}
+ 
+//
+// Unfreeze all the running timers.
+//
+void Timer::unfreezeTimers()
+{
+	PR_ASSERT(timersAreFrozen != 0);
+	timersAreFrozen--;
+
+	if (timersAreFrozen == 0) {
+		Vector<TimerEntry *> entries = timerEntries;
+		Uint32 count = entries.size();
+		
+		PRTime& newStart = getNewTimer();
+		
+		for (Uint32 i = 0; i < count; i++) {
+			TimerEntry& entry = *entries[i];
+			if (entry.running) {
+				entry.startTime = &newStart;
+			}
+		}
+		
+		newStart = PR_Now();
+	}
+}
+
+//
+// Print the named timer in the file f.
+//
+void Timer::print(FILE* f, const char *name)
+{
+	if (timersAreFrozen)
+		return;
+
+	freezeTimers();
+
+	TimerEntry& timer = getTimerEntry(name);
+  
+	PR_ASSERT(timer.done);
+	PRTime elapsed = timer.accumulator;
+
+	if (elapsed >> 32) {
+		fprintf(f, "[timer %s out of range]\n", name);
+	} else {
+		fprintf(f, "[%dus in %s]\n", Uint32(elapsed), name);
+	}
+	fflush(f);
+
+	unfreezeTimers();
+}
+

mozilla/ef/Compiler/RegisterAllocator/Timer.h

@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _TIMER_H_
+#define _TIMER_H_
+
+#include "Fundamentals.h"
+#include "HashTable.h"
+#include "prtime.h"
+
+//
+// Naming convention:
+//  As the class Timer contains only static methods, the timer's name should start with the 
+//  module name. Otherwise starting 2 timers with the same name will assert.
+//
+
+#ifndef NO_TIMER
+
+struct TimerEntry
+{
+	PRTime *startTime;					// Current time when we start the timer.
+	PRTime accumulator;					// Time spent in this timer.
+	bool running;						// True if the timer is running.
+	bool done;							// True if the timer was running and was stopped. 
+};
+
+class Timer
+{
+private:
+
+	// Return the named timer.
+	static TimerEntry& getTimerEntry(const char* name);
+	// Return a reference to a new Timer.
+	static PRTime& getNewTimer();
+
+public:
+
+	// Start the timer.
+	static void start(const char* name);
+	// Stop the timer.
+	static void stop(const char* name);
+	// Freeze all the running timers.
+	static void freezeTimers();
+	// Unfreeze all the running timers.
+	static void unfreezeTimers();
+	// Print the timer.
+	static void print(FILE* f, const char *name);
+};
+
+inline void startTimer(const char* name) 		{Timer::start(name);}
+inline void stopTimer(const char* name) 		{Timer::stop(name); Timer::print(stdout, name);}
+#define START_TIMER_SAFE						Timer::freezeTimers();
+#define END_TIMER_SAFE							Timer::unfreezeTimers();
+#define TIMER_SAFE(x)							START_TIMER_SAFE x; END_TIMER_SAFE
+
+#else /* NO_TIMER */
+
+inline void startTimer(const char* /*name*/) 	{} 
+inline void stopTimer(const char* /*name*/) 	{} 
+#define START_TIMER_SAFE
+#define END_TIMER_SAFE
+#define TIMER_SAFE(x)							x;
+
+#endif /* NO_TIMER */
+#endif /* _TIMER_H_ */

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.cpp

@@ -16,28 +16,25 @@
  * Reserved.
  */
 
-/*
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+#include "Instruction.h"
 
-  A sample of XPConnect. This file contains a sample interface.
+//------------------------------------------------------------------------------
+// VirtualRegister -
 
- */
+#ifdef MANUAL_TEMPLATES
+template class IndexedPool<VirtualRegister>;
+#endif
 
-#include "nsISupports.idl"
-
-[scriptable, uuid(7CB5B7A1-07D7-11d3-BDE2-000064657374)]
-interface nsISample : nsISupports
+// Set the defining instruction.
+//
+void VirtualRegister::setDefiningInstruction(Instruction& instruction)
 {
-    attribute string Value;
-    void WriteValue(in string aPrefix);
-    void Poke(in string aValue);
-};
+	if (definingInstruction != NULL) {
+		if ((instruction.getFlags() & ifCopy) && (definingInstruction->getFlags() & ifPhiNode))
+			return;
+	}
+	definingInstruction = &instruction;
+}
 
-
-%{ C++
-// {7CB5B7A0-07D7-11d3-BDE2-000064657374}
-#define NS_SAMPLE_CID \
-{ 0x7cb5b7a0, 0x7d7, 0x11d3, { 0xbd, 0xe2, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74 } }
-
-extern nsresult
-NS_NewSample(nsISample** aSample);
-%}

mozilla/ef/Compiler/RegisterAllocator/VirtualRegister.h

@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef _VIRTUAL_REGISTER_H_
+#define _VIRTUAL_REGISTER_H_
+
+#include "Fundamentals.h"
+#include "IndexedPool.h"
+#include <string.h>
+
+#include "RegisterTypes.h"
+#include "RegisterClass.h"
+
+
+//------------------------------------------------------------------------------
+// VirtualRegister - 24b
+
+class Instruction;
+
+class VirtualRegister : public IndexedObject<VirtualRegister>
+{
+public:
+
+	Instruction*					definingInstruction;	// Instruction defining this VR.
+
+	// Initialize a VR of the given classKind.
+	VirtualRegister(RegisterClassKind /*classKind*/) : definingInstruction(NULL) {}
+
+	// Return the defining instruction for this VR.
+	Instruction* getDefiningInstruction() const {return definingInstruction;}
+	// Set the defining instruction.
+	void setDefiningInstruction(Instruction& insn);
+};
+
+// Return true if the VirtualRegisters are equals. The only way 2 VRs can be equal is if
+// they have the same index. If they have the same index then they are at the same
+// address in the indexed pool.
+//
+inline bool operator == (const VirtualRegister& regA, const VirtualRegister& regB) {return &regA == &regB;}
+
+//------------------------------------------------------------------------------
+// VirtualRegisterManager -
+
+struct PreColoredRegister
+{
+	RegisterID id;
+	RegisterName color;
+};
+
+class VirtualRegisterManager
+{
+private:
+
+	IndexedPool<VirtualRegister> registerPool;
+	PreColoredRegister machineRegister[6];
+
+public:
+	VirtualRegisterManager()
+		{
+			for (Uint32 i = 0; i < 6; i++)
+				machineRegister[i].id = invalidID;
+		}
+
+	// Return the VirtualRegister at the given index.
+	VirtualRegister& getVirtualRegister(RegisterName name) const {return registerPool.get(name);}
+
+	// Return a new VirtualRegister.
+	RegisterID newVirtualRegister(RegisterClassKind classKind)
+		{
+			VirtualRegister& vReg = *new(registerPool) VirtualRegister(classKind);
+			RegisterID rid;
+
+			setName(rid, RegisterName(vReg.getIndex()));
+			setClass(rid, classKind);
+			return rid;
+		}
+
+	RegisterID newMachineRegister(RegisterName name, RegisterClassKind classKind)
+		{
+			RegisterID rid = machineRegister[name].id;
+
+			if (rid == invalidID) {
+				rid = newVirtualRegister(classKind);
+				DEBUG_ONLY(setMachineRegister(rid));
+				machineRegister[name].id = rid;
+				machineRegister[name].color = name;
+			}
+
+			return rid;
+		}
+
+	PreColoredRegister* getMachineRegistersBegin() const {return (PreColoredRegister*) machineRegister;} // FIX
+	PreColoredRegister* getMachineRegistersEnd() const {return (PreColoredRegister*) &machineRegister[6];} // FIX
+
+	// Return the VirtualRegister universe size.
+	Uint32 getSize() {return registerPool.getSize();}
+
+	void setSize(Uint32 size) {registerPool.setSize(size);}
+};
+
+#endif // _VIRTUAL_REGISTER_H_

mozilla/string/obsolete/nsStr.cpp

@@ -1,592 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL. 
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-  
-/******************************************************************************************
-  MODULE NOTES:
-
-  This file contains the nsStr data structure.
-  This general purpose buffer management class is used as the basis for our strings.
-  It's benefits include:
-    1. An efficient set of library style functions for manipulating nsStrs
-    2. Support for 1 and 2 byte character strings (which can easily be increased to n)
-    3. Unicode awareness and interoperability.
-
-*******************************************************************************************/
-
-#include "nsStr.h"
-#include "bufferRoutines.h"
-#include "stdio.h"  //only used for printf
-#include "nsDeque.h"
-#include "nsCRT.h"
-
-
-static const char* kFoolMsg = "Error: Some fool overwrote the shared buffer.";
-
-//----------------------------------------------------------------------------------------
-//  The following is a memory agent who knows how to recycled (pool) freed memory...
-//----------------------------------------------------------------------------------------
-
-/**************************************************************
-  Define the char* (pooled) deallocator class...
- **************************************************************/
-class nsBufferDeallocator: public nsDequeFunctor{
-public:
-  virtual void* operator()(void* anObject) {
-    char* aCString= (char*)anObject;
-    delete [] aCString;
-    return 0;
-  }
-};
-
-/**
- * 
- * @update	gess10/30/98
- * @param 
- * @return
- */
-class nsPoolingMemoryAgent : public nsMemoryAgent{
-public:
-  nsPoolingMemoryAgent()  {
-    memset(mPools,0,sizeof(mPools));
-  }
-
-  virtual ~nsPoolingMemoryAgent() {
-    nsBufferDeallocator theDeallocator;
-    int i=0;
-    for(i=0;i<10;i++){
-      if(mPools[i]){
-        mPools[i]->ForEach(theDeallocator); //now delete the buffers
-      }
-      delete mPools[i];
-      mPools[i]=0;
-    }
-  }
-
-  virtual PRBool Alloc(nsStr& aDest,PRUint32 aCount) {
-    
-    //we're given the acount value in charunits; we have to scale up by the charsize.
-    int       theShift=4;
-    PRUint32  theNewCapacity=eDefaultSize;
-    while(theNewCapacity<aCount){ 
-      theNewCapacity<<=1;
-      theShift++;
-    } 
-    
-    aDest.mCapacity=theNewCapacity++;
-    theShift=(theShift<<aDest.mCharSize)-4;
-    if((theShift<12) && (mPools[theShift])){
-      aDest.mStr=(char*)mPools[theShift]->Pop();
-    }
-    if(!aDest.mStr) {
-      //we're given the acount value in charunits; we have to scale up by the charsize.
-      size_t theSize=(theNewCapacity<<aDest.mCharSize);
-      aDest.mStr=new char[theSize];    
-    }
-    aDest.mOwnsBuffer=1;
-    return PRBool(aDest.mStr!=0);
-    
-  }
-
-  virtual PRBool Free(nsStr& aDest){
-    if(aDest.mStr){
-      if(aDest.mOwnsBuffer){
-        int theShift=1;
-        unsigned int theValue=1;
-        while((theValue<<=1)<aDest.mCapacity){ 
-          theShift++;
-        }
-        theShift-=4;
-        if(theShift<12){
-          if(!mPools[theShift]){
-            mPools[theShift]=new nsDeque(0);
-          }
-          mPools[theShift]->Push(aDest.mStr);
-        }
-        else delete [] aDest.mStr; //it's too big. Just delete it.
-      }
-      aDest.mStr=0;
-      aDest.mOwnsBuffer=0;
-      return PR_TRUE;
-    }
-    return PR_FALSE;
-  }
-  nsDeque* mPools[16]; 
-};
-
-static char* gCommonEmptyBuffer=0;
-/**
- * 
- * @update	gess10/30/98
- * @param 
- * @return
- */
-char* GetSharedEmptyBuffer() {
-  if(!gCommonEmptyBuffer) {
-    const size_t theDfltSize=5;
-    gCommonEmptyBuffer=new char[theDfltSize];
-    if(gCommonEmptyBuffer){
-      nsCRT::zero(gCommonEmptyBuffer,theDfltSize);
-      gCommonEmptyBuffer[0]=0;
-    }
-    else {
-      printf("%s\n","Memory allocation error!");
-    }
-  }
-  return gCommonEmptyBuffer;
-}
-
-/**
- * 
- * @update	gess10/30/98
- * @param 
- * @return
- */
-void nsStr::Initialize(nsStr& aDest,eCharSize aCharSize) {
-  aDest.mStr=GetSharedEmptyBuffer();
-  aDest.mLength=0;
-  aDest.mCapacity=0;
-  aDest.mCharSize=aCharSize;
-  aDest.mOwnsBuffer=0;
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * 
- * @update	gess10/30/98
- * @param 
- * @return
- */
-void nsStr::Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer){
-  aDest.mStr=(aCString) ? aCString : GetSharedEmptyBuffer();
-  aDest.mLength=aLength;
-  aDest.mCapacity=aCapacity;
-  aDest.mCharSize=aCharSize;
-  aDest.mOwnsBuffer=aOwnsBuffer;
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * 
- * @update	gess10/30/98
- * @param 
- * @return
- */
-nsIMemoryAgent* GetDefaultAgent(void){
-//  static nsPoolingMemoryAgent gDefaultAgent;
-  static nsMemoryAgent gDefaultAgent;
-  return (nsIMemoryAgent*)&gDefaultAgent;
-}
-
-/**
- * 
- * @update	gess10/30/98
- * @param 
- * @return
- */
-void nsStr::Destroy(nsStr& aDest,nsIMemoryAgent* anAgent) {
-  if((aDest.mStr) && (aDest.mStr!=GetSharedEmptyBuffer())) {
-    if(!anAgent)
-      anAgent=GetDefaultAgent();
-    
-    if(anAgent) {
-      anAgent->Free(aDest);
-    }
-    else{
-      printf("%s\n","Leak occured in nsStr.");
-    }
-  }
-}
-
-
-/**
- * This method gets called when the internal buffer needs
- * to grow to a given size. The original contents are not preserved.
- * @update  gess 3/30/98
- * @param   aNewLength -- new capacity of string in charSize units
- * @return  void
- */
-void nsStr::EnsureCapacity(nsStr& aString,PRUint32 aNewLength,nsIMemoryAgent* anAgent) {
-  if(aNewLength>aString.mCapacity) {
-    nsIMemoryAgent* theAgent=(anAgent) ? anAgent : GetDefaultAgent();
-    theAgent->Realloc(aString,aNewLength);
-    AddNullTerminator(aString);
-  }
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * This method gets called when the internal buffer needs
- * to grow to a given size. The original contents ARE preserved.
- * @update  gess 3/30/98
- * @param   aNewLength -- new capacity of string in charSize units
- * @return  void
- */
-void nsStr::GrowCapacity(nsStr& aDest,PRUint32 aNewLength,nsIMemoryAgent* anAgent) {
-  if(aNewLength>aDest.mCapacity) {
-    nsStr theTempStr;
-    nsStr::Initialize(theTempStr,aDest.mCharSize);
-
-    nsIMemoryAgent* theAgent=(anAgent) ? anAgent : GetDefaultAgent();
-    EnsureCapacity(theTempStr,aNewLength,theAgent);
-
-    if(aDest.mLength) {
-      Append(theTempStr,aDest,0,aDest.mLength,theAgent);        
-    } 
-    theAgent->Free(aDest);
-    aDest.mStr = theTempStr.mStr;
-    theTempStr.mStr=0; //make sure to null this out so that you don't lose the buffer you just stole...
-    aDest.mLength=theTempStr.mLength;
-    aDest.mCapacity=theTempStr.mCapacity;
-    aDest.mOwnsBuffer=theTempStr.mOwnsBuffer;
-  }
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * Replaces the contents of aDest with aSource, up to aCount of chars.
- * @update	gess10/30/98
- * @param   aDest is the nsStr that gets changed.
- * @param   aSource is where chars are copied from
- * @param   aCount is the number of chars copied from aSource
- */
-void nsStr::Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount,nsIMemoryAgent* anAgent){
-  if(&aDest!=&aSource){
-    Truncate(aDest,0,anAgent);
-    Append(aDest,aSource,anOffset,aCount,anAgent);
-  }
-}
-
-/**
- * This method appends the given nsStr to this one. Note that we have to 
- * pay attention to the underlying char-size of both structs.
- * @update	gess10/30/98
- * @param   aDest is the nsStr to be manipulated
- * @param   aSource is where char are copied from
- * @aCount  is the number of bytes to be copied 
- */
-void nsStr::Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount,nsIMemoryAgent* anAgent){
-  if(anOffset<aSource.mLength){
-    PRUint32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
-    PRUint32 theLength=(anOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-anOffset);
-    if(0<theLength){
-      if(aDest.mLength+theLength > aDest.mCapacity) {
-        GrowCapacity(aDest,aDest.mLength+theLength,anAgent);
-      }
-
-      //now append new chars, starting at offset
-      (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDest.mLength,aSource.mStr,anOffset,theLength);
-
-      aDest.mLength+=theLength;
-    }
-  }
-  AddNullTerminator(aDest);
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-
-/**
- * This method inserts up to "aCount" chars from a source nsStr into a dest nsStr.
- * @update	gess10/30/98
- * @param   aDest is the nsStr that gets changed
- * @param   aDestOffset is where in aDest the insertion is to occur
- * @param   aSource is where chars are copied from
- * @param   aSrcOffset is where in aSource chars are copied from
- * @param   aCount is the number of chars from aSource to be inserted into aDest
- */
-void nsStr::Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount,nsIMemoryAgent* anAgent){
-  //there are a few cases for insert:
-  //  1. You're inserting chars into an empty string (assign)
-  //  2. You're inserting onto the end of a string (append)
-  //  3. You're inserting onto the 1..n-1 pos of a string (the hard case).
-  if(0<aSource.mLength){
-    if(aDest.mLength){
-      if(aDestOffset<aDest.mLength){
-        PRInt32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
-        PRInt32 theLength=(aSrcOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-aSrcOffset);
-
-        if(aSrcOffset<aSource.mLength) {
-            //here's the only new case we have to handle. 
-            //chars are really being inserted into our buffer...
-          GrowCapacity(aDest,aDest.mLength+theLength,anAgent);
-
-            //shift the chars right by theDelta...
-          (*gShiftChars[aDest.mCharSize][KSHIFTRIGHT])(aDest.mStr,aDest.mLength,aDestOffset,theLength);
-      
-          //now insert new chars, starting at offset
-          (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDestOffset,aSource.mStr,aSrcOffset,theLength);
-
-          //finally, make sure to update the string length...
-          aDest.mLength+=theLength;
-          AddNullTerminator(aDest);
-
-        }//if
-        //else nothing to do!
-      }
-      else Append(aDest,aSource,0,aCount,anAgent);
-    }
-    else Append(aDest,aSource,0,aCount,anAgent);
-  }
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-
-/**
- * This method deletes up to aCount chars from aDest
- * @update	gess10/30/98
- * @param   aDest is the nsStr to be manipulated
- * @param   aDestOffset is where in aDest deletion is to occur
- * @param   aCount is the number of chars to be deleted in aDest
- */
-void nsStr::Delete(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount,nsIMemoryAgent* anAgent){
-  if(aDestOffset<aDest.mLength){
-
-    PRUint32 theDelta=aDest.mLength-aDestOffset;
-    PRUint32 theLength=(theDelta<aCount) ? theDelta : aCount;
-
-    if(aDestOffset+theLength<aDest.mLength) {
-
-      //if you're here, it means we're cutting chars out of the middle of the string...
-      //so shift the chars left by theLength...
-      (*gShiftChars[aDest.mCharSize][KSHIFTLEFT])(aDest.mStr,aDest.mLength,aDestOffset,theLength);
-      aDest.mLength-=theLength;
-    }
-    else Truncate(aDest,aDestOffset,anAgent);
-  }//if
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * This method truncates the given nsStr at given offset
- * @update	gess10/30/98
- * @param   aDest is the nsStr to be truncated
- * @param   aDestOffset is where in aDest truncation is to occur
- */
-void nsStr::Truncate(nsStr& aDest,PRUint32 aDestOffset,nsIMemoryAgent* anAgent){
-  if(aDestOffset<aDest.mLength){
-    aDest.mLength=aDestOffset;
-    AddNullTerminator(aDest);
-  }
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::ChangeCase(nsStr& aDest,PRBool aToUpper) {
-  // somehow UnicharUtil return failed, fallback to the old ascii only code
-  gCaseConverters[aDest.mCharSize](aDest.mStr,aDest.mLength,aToUpper);
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::StripChars(nsStr& aDest,PRUint32 aDestOffset,PRInt32 aCount,const char* aCharSet){
-  PRUint32 aNewLen=gStripChars[aDest.mCharSize](aDest.mStr,aDestOffset,aCount,aCharSet);
-  aDest.mLength=aNewLen;
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing){
-  PRUint32 aNewLen=gTrimChars[aDest.mCharSize](aDest.mStr,aDest.mLength,aSet,aEliminateLeading,aEliminateTrailing);
-  aDest.mLength=aNewLen;
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::CompressSet(nsStr& aDest,const char* aSet,PRUint32 aChar,PRBool aEliminateLeading,PRBool aEliminateTrailing){
-  PRUint32 aNewLen=gCompressChars[aDest.mCharSize](aDest.mStr,aDest.mLength,aSet,aChar,aEliminateLeading,aEliminateTrailing);
-  aDest.mLength=aNewLen;
-  NS_ASSERTION(gCommonEmptyBuffer[0]==0,kFoolMsg);
-}
-
-  /**************************************************************
-    Searching methods...
-   **************************************************************/
-
-
-PRInt32 nsStr::FindSubstr(const nsStr& aDest,const nsStr& aTarget, PRBool aIgnoreCase,PRUint32 anOffset) {
-  if((aDest.mLength>0) && (aTarget.mLength>0) && (anOffset<aTarget.mLength)){
-
-    int32 index=anOffset-1;
-    int32 theMax=aDest.mLength-aTarget.mLength;
-    if((aDest.mLength>0) && (aTarget.mLength>0)){
-      int32 theTargetMax=aTarget.mLength;
-      while(++index<=theMax) {
-        int32 theSubIndex=-1;
-        PRBool  matches=PR_TRUE;
-        while((++theSubIndex<theTargetMax) && (matches)){
-          PRUnichar theChar=(aIgnoreCase) ? nsCRT::ToLower(GetCharAt(aDest,index+theSubIndex)) : GetCharAt(aDest,index+theSubIndex);
-          PRUnichar theTargetChar=(aIgnoreCase) ? nsCRT::ToLower(GetCharAt(aTarget,theSubIndex)) : GetCharAt(aTarget,theSubIndex);
-          matches=PRBool(theChar==theTargetChar);
-        }
-        if(matches) { 
-          return index;
-        }
-      }
-    }//if
-  }
-  return kNotFound;
-}
-
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-PRInt32 nsStr::FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRUint32 anOffset) {
-  PRInt32 result=gFindChars[aDest.mCharSize](aDest.mStr,aDest.mLength,anOffset,aChar,aIgnoreCase);
-  return result;
-}
-
-
-/**
- *  
- *  
- *  @update  gess 3/25/98
- *  @param   
- *  @return  
- */
-PRInt32 nsStr::FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRUint32 anOffset) {
-  PRUint32 index=anOffset-1;
-  PRInt32  thePos;
-
-  while(++index<aDest.mLength) {
-    PRUnichar theChar=GetCharAt(aDest,index);
-    thePos=gFindChars[aSet.mCharSize](aSet.mStr,aSet.mLength,0,theChar,aIgnoreCase);
-    if(kNotFound!=thePos)
-      return index;
-  } //while
-  return kNotFound;
-}
-
-  /**************************************************************
-    Reverse Searching methods...
-   **************************************************************/
-
-
-PRInt32 nsStr::RFindSubstr(const nsStr& aDest,const nsStr& aTarget, PRBool aIgnoreCase,PRUint32 anOffset) {
-  PRInt32 index=(anOffset ? anOffset : aDest.mLength-aTarget.mLength+1);
-  PRInt32 result=kNotFound;
-
-  if((aDest.mLength>0) && (aTarget.mLength>0)){
-
-    nsStr theCopy;
-    nsStr::Initialize(theCopy,eOneByte);
-    nsStr::Assign(theCopy,aTarget,0,aTarget.mLength,0);
-    if(aIgnoreCase){
-      nsStr::ChangeCase(theCopy,PR_FALSE); //force to lowercase
-    }
-    
-    int32   theTargetMax=theCopy.mLength;
-    while(index--) {
-      int32 theSubIndex=-1;
-      PRBool  matches=PR_TRUE;
-      if(anOffset+theCopy.mLength<=aDest.mLength) {
-        while((++theSubIndex<theTargetMax) && (matches)){
-          PRUnichar theDestChar=(aIgnoreCase) ? nsCRT::ToLower(GetCharAt(aDest,index+theSubIndex)) : GetCharAt(aDest,index+theSubIndex);
-          PRUnichar theTargetChar=GetCharAt(theCopy,theSubIndex);
-          matches=PRBool(theDestChar==theTargetChar);
-        } //while
-      } //if
-      if(matches) {
-        result=index;
-        break;
-      }
-    } //while
-    nsStr::Destroy(theCopy,0);
-  }//if
-  return result;
-}
- 
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-PRInt32 nsStr::RFindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRUint32 anOffset) {
-  PRInt32 result=gRFindChars[aDest.mCharSize](aDest.mStr,aDest.mLength,anOffset,aChar,aIgnoreCase);
-  return result;
-}
-
-/**
- *  
- *  
- *  @update  gess 3/25/98
- *  @param   
- *  @return  
- */
-PRInt32 nsStr::RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRUint32 anOffset) {
-  PRUint32 offset=aDest.mLength-anOffset;
-  PRInt32  thePos;
-
-  while(--offset>=0) {
-    PRUnichar theChar=GetCharAt(aDest,offset);
-    thePos=gRFindChars[aSet.mCharSize](aSet.mStr,aSet.mLength,0,theChar,aIgnoreCase);
-    if(kNotFound!=thePos)
-      return offset;
-  } //while
-  return kNotFound;
-}
-
-
-/**
- * 
- * @update	gess11/12/98
- * @param 
- * @return  aDest<aSource=-1;aDest==aSource==0;aDest>aSource=1
- */
-PRInt32 nsStr::Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) {
-  int minlen=(aSource.mLength<aDest.mLength) ? aSource.mLength : aDest.mLength;
-
-  if(0==minlen) {
-    if ((aDest.mLength == 0) && (aSource.mLength == 0))
-      return 0;
-    if (aDest.mLength == 0)
-      return -1;
-    return 1;
-  }
-
-  int maxlen=(aSource.mLength<aDest.mLength) ? aDest.mLength : aSource.mLength;
-  PRInt32 result=(*gCompare[aDest.mCharSize][aSource.mCharSize])(aDest.mStr,aSource.mStr,maxlen,aIgnoreCase);
-  return result;
-}
-

mozilla/string/obsolete/nsStr.h

@@ -1,333 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-/***********************************************************************
-  MODULE NOTES:
-
-    1. There are two philosophies to building string classes:
-        A. Hide the underlying buffer & offer API's allow indirect iteration
-        B. Reveal underlying buffer, risk corruption, but gain performance
-        
-       We chose the option B for performance reasons. 
-
-    2  Our internal buffer always holds capacity+1 bytes.
-
-    The nsStr struct is a simple structure (no methods) that contains
-    the necessary info to be described as a string. This simple struct
-    is manipulated by the static methods provided in this class. 
-    (Which effectively makes this a library that works on structs).
-
-    There are also object-based versions called nsString and nsAutoString
-    which use nsStr but makes it look at feel like an object. 
-
- ***********************************************************************/
-
-
-#ifndef _nsStr
-#define _nsStr
-
-#include "nscore.h"
-
-//----------------------------------------------------------------------------------------
-
-enum  eCharSize {eOneByte=0,eTwoByte=1};
-#define kDefaultCharSize eTwoByte
-const PRInt32 kNotFound = -1;
-
-
-class nsIMemoryAgent;
-
-//----------------------------------------------------------------------------------------
-
-
-struct nsStr {  
-
- /**
-  * This method initializes an nsStr for use
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be initialized
-  * @param  aCharSize tells us the requested char size (1 or 2 bytes)
-  */
-  static void Initialize(nsStr& aDest,eCharSize aCharSize);
-
- /**
-  * This method initializes an nsStr for use
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be initialized
-  * @param  aCharSize tells us the requested char size (1 or 2 bytes)
-  */
-  static void Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer);
-
- /**
-  * This method destroys the given nsStr, and *MAY* 
-  * deallocate it's memory depending on the setting
-  * of the internal mOwnsBUffer flag.
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be manipulated
-  * @param  anAgent is the allocator to be used to the nsStr
-  */
-  static void Destroy(nsStr& aDest,nsIMemoryAgent* anAgent=0); 
-
- /**
-  * These methods are where memory allocation/reallocation occur. 
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be manipulated
-  * @param  anAgent is the allocator to be used on the nsStr
-  * @return  
-  */
-  static void EnsureCapacity(nsStr& aString,PRUint32 aNewLength,nsIMemoryAgent* anAgent=0);
-  static void GrowCapacity(nsStr& aString,PRUint32 aNewLength,nsIMemoryAgent* anAgent=0);
-
- /**
-  * These methods are used to append content to the given nsStr
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aSource is the buffer to be copied from
-  * @param  anOffset tells us where in source to start copying
-  * @param  aCount tells us the (max) # of chars to copy
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount,nsIMemoryAgent* anAgent=0);
-
- /**
-  * These methods are used to assign contents of a source string to dest string
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aSource is the buffer to be copied from
-  * @param  anOffset tells us where in source to start copying
-  * @param  aCount tells us the (max) # of chars to copy
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount,nsIMemoryAgent* anAgent=0);
-
- /**
-  * These methods are used to insert content from source string to the dest nsStr
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aDestOffset tells us where in dest to start insertion
-  * @param  aSource is the buffer to be copied from
-  * @param  aSrcOffset tells us where in source to start copying
-  * @param  aCount tells us the (max) # of chars to insert
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount,nsIMemoryAgent* anAgent=0);
-
- /**
-  * This method deletes chars from the given str. 
-  * The given allocator may choose to resize the str as well.
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be deleted from
-  * @param  aDestOffset tells us where in dest to start deleting
-  * @param  aCount tells us the (max) # of chars to delete
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Delete(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount,nsIMemoryAgent* anAgent=0);
-
- /**
-  * This method is used to truncate the given string.
-  * The given allocator may choose to resize the str as well (but it's not likely).
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aDestOffset tells us where in dest to start insertion
-  * @param  aSource is the buffer to be copied from
-  * @param  aSrcOffset tells us where in source to start copying
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Truncate(nsStr& aDest,PRUint32 aDestOffset,nsIMemoryAgent* anAgent=0);
-
- /**
-  * This method is used to perform a case conversion on the given string
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be case shifted
-  * @param  toUpper tells us to go upper vs. lower
-  */
-  static void ChangeCase(nsStr& aDest,PRBool aToUpper);
-
-  /**
-   * This method removes chars (given in aSet) from the given buffer 
-   *
-   * @update	gess 01/04/99
-   * @param   aString is the buffer to be manipulated
-   * @param   aDestOffset is starting pos in buffer for manipulation
-   * @param   aCount is the number of chars to compare
-   * @param   aSet tells us which chars to remove from given buffer
-   */
-  static void StripChars(nsStr& aDest,PRUint32 aDestOffset,PRInt32 aCount,const char* aCharSet);
-
-  /**
-   * This method trims chars (given in aSet) from the edges of given buffer 
-   *
-   * @update	gess 01/04/99
-   * @param   aDest is the buffer to be manipulated
-   * @param   aSet tells us which chars to remove from given buffer
-   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
-   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
-   */
-  static void Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing);
-  
-  /**
-   * This method compresses duplicate runs of a given char from the given buffer 
-   *
-   * @update	gess 01/04/99
-   * @param   aDest is the buffer to be manipulated
-   * @param   aSet tells us which chars to compress from given buffer
-   * @param   aChar is the replacement char
-   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
-   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
-   */
-  static void CompressSet(nsStr& aDest,const char* aSet,PRUint32 aChar,PRBool aEliminateLeading,PRBool aEliminateTrailing);
-
-  /**
-   * This method compares the data bewteen two nsStr's 
-   *
-   * @update	gess 01/04/99
-   * @param   aStr1 is the first buffer to be compared
-   * @param   aStr2 is the 2nd buffer to be compared
-   * @param   aCount is the number of chars to compare
-   * @param   aIgnorecase tells us whether to use a case-sensitive comparison
-   * @return  -1,0,1 depending on <,==,>
-   */
-  static PRInt32  Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase);
-
- /**
-  * These methods scan the given string for 1 or more chars in a given direction
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be searched to
-  * @param  aSource (or aChar) is the substr we're looking to find
-  * @param  aIgnoreCase tells us whether to search in a case-sensitive manner
-  * @param  anOffset tells us where in the dest string to start searching
-  * @return the index of the source (substr) in dest, or -1 (kNotFound) if not found.
-  */
-  static PRInt32 FindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRUint32 anOffset);
-  static PRInt32 FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRUint32 anOffset);
-  static PRInt32 FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRUint32 anOffset);
-
-  static PRInt32 RFindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRUint32 anOffset);
-  static PRInt32 RFindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRUint32 anOffset);
-  static PRInt32 RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRUint32 anOffset);
-
-
-  PRUint32        mLength;
-  PRUint32        mCapacity;
-  eCharSize       mCharSize;
-  PRBool          mOwnsBuffer;
-
-  union { 
-    char*         mStr;
-    PRUnichar*    mUStr;
-  };
-};
-
-/**************************************************************
-  A couple of tiny helper methods used in the string classes.
- **************************************************************/
-
-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;
-}
-
-/**
-* This method is used to access a given char in the given string
-*
-* @update	gess 01/04/99
-* @param  aDest is the nsStr to be appended to
-* @param  anIndex tells us where in dest to get the char from
-* @return the given char, or 0 if anIndex is out of range
-*/
-inline PRUnichar GetCharAt(const nsStr& aDest,PRUint32 anIndex){
-  if(anIndex<aDest.mLength)  {
-    return (eTwoByte==aDest.mCharSize) ? aDest.mUStr[anIndex] : aDest.mStr[anIndex];
-  }//if
-  return 0;
-}
-
-//----------------------------------------------------------------------------------------
-
-class nsIMemoryAgent {
-public:
-  virtual PRBool Alloc(nsStr& aString,PRUint32 aCount)=0;
-  virtual PRBool Realloc(nsStr& aString,PRUint32 aCount)=0;
-  virtual PRBool Free(nsStr& aString)=0;
-};
-
-class nsMemoryAgent : public nsIMemoryAgent {
-protected:
-  enum eDelta{eDefaultSize=16};
-public:
-
-  virtual PRBool Alloc(nsStr& aDest,PRUint32 aCount) {
-    
-    //we're given the acount value in charunits; now scale up to next multiple.
-  	PRUint32	theNewCapacity=eDefaultSize;
-    while(theNewCapacity<aCount){ 
-		  theNewCapacity<<=1;
-    }
-	  
-    aDest.mCapacity=theNewCapacity++;
-    size_t theSize=(theNewCapacity<<aDest.mCharSize);
-    aDest.mStr=new char[theSize];
-    aDest.mOwnsBuffer=1;
-    return PR_TRUE;
-  }
-
-  virtual PRBool Free(nsStr& aDest){
-    if(aDest.mStr){
-      if(aDest.mOwnsBuffer){
-        delete [] aDest.mStr;
-      }
-      aDest.mStr=0;
-      aDest.mOwnsBuffer=0;
-      return PR_TRUE;
-    }
-    return PR_FALSE;
-  }
-
-  virtual PRBool Realloc(nsStr& aDest,PRUint32 aCount){
-    Free(aDest);
-    return Alloc(aDest,aCount);
-  }
-
-};
-
-char* GetSharedEmptyBuffer();
-nsIMemoryAgent* GetDefaultAgent(void);
-
-#endif
-

mozilla/string/obsolete/nsString.h

@@ -1,819 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-/***********************************************************************
-  MODULE NOTES:
-
-    A. There are two philosophies to building string classes:
-        1. Hide the underlying buffer & offer API's allow indirect iteration
-        2. Reveal underlying buffer, risk corruption, but gain performance
-        
-       We chose the second option for performance reasons. 
-
-    B Our internal buffer always holds capacity+1 bytes.
- ***********************************************************************/
-
-
-#ifndef _nsString1
-#define _nsString1
-
-
-#include "prtypes.h"
-#include "nscore.h"
-#include "nsIAtom.h"
-#include <iostream.h>
-#include <stdio.h>
-#include "nsStr.h"
-
-#include "nsString2.h"  //get new string class
-
-class nsISizeOfHandler;
-
-class NS_COM nsString1 {
-  public: 
-
-/**
- * Default constructor. Note that we actually allocate a small buffer
- * to begin with. This is because the "philosophy" of the string class
- * was to allow developers direct access to the underlying buffer for
- * performance reasons. 
- */
-nsString1();
-
-/**
- * This constructor accepts an isolatin string
- * @param   an ascii is a ptr to a 1-byte cstr
- */
-nsString1(const char* aCString);
-
-/**
- * This is our copy constructor 
- * @param   reference to another nsString1
- */
-nsString1(const nsString1&);
-
-/**
- * Constructor from a unicode string
- * @param   anicodestr pts to a unicode string
- */
-nsString1(const PRUnichar* aUnicode);    
-
-/**
- * Virtual Destructor
- */
-virtual ~nsString1();
-
-
-/**
- * Retrieve the length of this string
- * @return string length
- */
-PRInt32 Length() const { return mLength; }
-
-
-/**
- * Sets the new length of the string.
- * @param   aLength is new string length.
- * @return  nada
- */
-void SetLength(PRInt32 aLength);
-
-/**
- * This method truncates this string to given length.
- *
- * @param   anIndex -- new length of string
- * @return  nada
- */
-void Truncate(PRInt32 anIndex=0);
-
-
-/**
- * This method gets called when the internal buffer needs
- * to grow to a given size.
- * @param   aNewLength -- new capacity of string  
- * @return  void
- */
-virtual void EnsureCapacityFor(PRInt32 aNewLength);
-
-/**
- * 
- * @param 
- */
-virtual void SizeOf(nsISizeOfHandler* aHandler) const;
-
-/**
- *  Determine whether or not the characters in this
- *  string are in sorted order.
- *  
- *  @return  TRUE if ordered.
- */
-PRBool IsOrdered(void) const;
-
-/**
- *  Determine whether or not this string has a length of 0
- *  
- *  @return  TRUE if empty.
- */
-PRBool IsEmpty(void) const {
-  return PRBool(0==mLength);
-}
-
-/**********************************************************************
-  Accessor methods...
- *********************************************************************/
-
-/**
- * Retrieve pointer to internal string value
- * @return  PRUnichar* to internal string
- */
-const PRUnichar* GetUnicode(void) const;
-
-/**
- * 
- * @param 
- * @return
- */
-operator const PRUnichar*() const;
-
-/**
- * Retrieve unicode char at given index
- * @param   offset into string
- * @return  PRUnichar* to internal string
- */
-//PRUnichar operator()(PRInt32 anIndex) const;
-
-/**
- * Retrieve reference to unicode char at given index
- * @param   offset into string
- * @return  PRUnichar& from internal string
- */
-PRUnichar& operator[](PRInt32 anIndex) const;
-
-/**
- * Retrieve reference to unicode char at given index
- * @param   offset into string
- * @return  PRUnichar& from internal string
- */
-PRUnichar& CharAt(PRInt32 anIndex) const;
-
-/**
- * Retrieve reference to first unicode char in string
- * @return  PRUnichar from internal string
- */
-PRUnichar& First() const; 
-
-/**
- * Retrieve reference to last unicode char in string
- * @return  PRUnichar from internal string
- */
-PRUnichar& Last() const;
-
-PRBool SetCharAt(PRUnichar aChar,PRInt32 anIndex);
-
-
-/**********************************************************************
-  String creation methods...
- *********************************************************************/
-
-/**
- * Create a new string by appending given string to this
- * @param   aString -- 2nd string to be appended
- * @return  new string
- */
-nsString1 operator+(const nsString1& aString);
-
-/**
- * create a new string by adding this to the given buffer.
- * @param   aCString is a ptr to cstring to be added to this
- * @return  newly created string
- */
-nsString1 operator+(const char* aCString);
-
-/**
- * create a new string by adding this to the given char.
- * @param   aChar is a char to be added to this
- * @return  newly created string
- */
-nsString1 operator+(char aChar);
-
-/**
- * create a new string by adding this to the given buffer.
- * @param   aStr unichar buffer to be added to this
- * @return  newly created string
- */
-nsString1 operator+(const PRUnichar* aBuffer);
-
-/**
- * create a new string by adding this to the given char.
- * @param   aChar is a unichar to be added to this
- * @return  newly created string
- */
-nsString1 operator+(PRUnichar aChar);
-
-/**
- * Converts all chars in internal string to lower
- */
-void ToLowerCase();
-
-/**
- * Converts all chars in given string to lower
- */
-void ToLowerCase(nsString1& aString) const;
-
-/**
- * Converts all chars in given string to upper
- */
-void ToUpperCase();
-
-/**
- * Converts all chars in given string to UCS2
- * which ensure that the lower 256 chars are correct.
- */
-void ToUCS2(PRInt32 aStartOffset);
-
-/**
- * Converts all chars in internal string to upper
- */
-void ToUpperCase(nsString1& aString) const;
-
-/**
- * Creates a duplicate clone (ptr) of this string.
- * @return  ptr to clone of this string
- */
-nsString1* ToNewString() const;
-
-/**
- * Creates an ascii clone of this string
- * NOTE: This string is allocated with new; YOU MUST deallocate with delete[]!
- * @return  ptr to new c-String string
- */
-char* ToNewCString() const;
-
-/**
- * Copies data from internal buffer onto given char* buffer
- * @param aBuf is the buffer where data is stored
- * @param aBuflength is the max # of chars to move to buffer
- * @return ptr to given buffer
- */
-char* ToCString(char* aBuf,PRInt32 aBufLength) const;
-
-/**
- * Copies contents of this onto given string.
- * @param   aString to hold copy of this
- * @return  nada.
- */
-void Copy(nsString1& aString) const;
-
-/**
- * Creates an unichar clone of this string
- * @return  ptr to new unichar string
- */
-PRUnichar* ToNewUnicode() const;
-
-/**
- * Perform string to float conversion.
- * @param   aErrorCode will contain error if one occurs
- * @return  float rep of string value
- */
-float ToFloat(PRInt32* aErrorCode) const;
-
-/**
- * Perform string to int conversion.
- * @param   aErrorCode will contain error if one occurs
- * @return  int rep of string value
- */
-PRInt32 ToInteger(PRInt32* aErrorCode,PRInt32 aRadix=10) const;
-
-/**********************************************************************
-  String manipulation methods...                
- *********************************************************************/
-
-/**
- * assign given PRUnichar* to this string
- * @param   aStr: buffer to be assigned to this 
- * @param   alength is the length of the given str (or -1)
-            if you want me to determine its length
- * @return  this
- */
-nsString1& SetString(const PRUnichar* aStr,PRInt32 aLength=-1);
-nsString1& SetString(const char* aCString,PRInt32 aLength=-1);
-nsString1& SetString(const nsString1& aString);
-
-/**
- * assign given string to this one
- * @param   aString: string to be added to this
- * @return  this
- */
-nsString1& operator=(const nsString1& aString);
-
-/**
- * assign given char* to this string
- * @param   aCString: buffer to be assigned to this 
- * @return  this
- */
-nsString1& operator=(const char* aCString);
-
-/**
- * assign given char to this string
- * @param   aChar: char to be assignd to this
- * @return  this
- */
-nsString1& operator=(char aChar);
-
-/**
- * assign given unichar* to this string
- * @param   aBuffer: unichar buffer to be assigned to this 
- * @return  this
- */
-nsString1& operator=(const PRUnichar* aBuffer);
-
-/**
- * assign given char to this string
- * @param   aChar: char to be assignd to this
- * @return  this
- */
-nsString1& operator=(PRUnichar aChar);
-
-/**
- * append given string to this string
- * @param   aString : string to be appended to this
- * @return  this
- */
-nsString1& operator+=(const nsString1& aString);
-
-/**
- * append given buffer to this string
- * @param   aCString: buffer to be appended to this
- * @return  this
- */
-nsString1& operator+=(const char* aCString);
-
-/**
- * append given buffer to this string
- * @param   aBuffer: buffer to be appended to this
- * @return  this
- */
-nsString1& operator+=(const PRUnichar* aBuffer);
-
-/**
- * append given char to this string
- * @param   aChar: char to be appended to this
- * @return  this
- */
-nsString1& operator+=(PRUnichar aChar);
-
-/**
- * append given string to this string
- * @param   aString : string to be appended to this
- * @param   alength is the length of the given str (or -1)
-            if you want me to determine its length
- * @return  this
- */
-nsString1& Append(const nsString1& aString,PRInt32 aLength=-1);
-
-/**
- * append given string to this string
- * @param   aString : string to be appended to this
- * @param   alength is the length of the given str (or -1)
-            if you want me to determine its length
- * @return  this
- */
-nsString1& Append(const char* aCString,PRInt32 aLength=-1);
-
-/**
- * append given string to this string
- * @param   aString : string to be appended to this
- * @return  this
- */
-nsString1& Append(char aChar);
-
-/**
- * append given unichar buffer to this string
- * @param   aString : string to be appended to this
- * @param   alength is the length of the given str (or -1)
-            if you want me to determine its length
- * @return  this
- */
-nsString1& Append(const PRUnichar* aBuffer,PRInt32 aLength=-1);
-
-/**
- * append given unichar character to this string
- * @param   aChar is the char to be appended to this
- * @return  this
- */
-nsString1& Append(PRUnichar aChar);
-
-/**
- * Append an integer onto this string
- * @param aInteger is the int to be appended
- * @param aRadix specifies 8,10,16
- * @return this
- */
-nsString1& Append(PRInt32 aInteger,PRInt32 aRadix); //radix=8,10 or 16
-
-/**
- * Append a float value onto this string
- * @param aFloat is the float to be appended
- * @return this
- */
-nsString1& Append(float aFloat);
-              
-/*
- *  Copies n characters from this string to given string,
- *  starting at the leftmost offset.
- *  
- *  
- *  @param   aCopy -- Receiving string
- *  @param   aCount -- number of chars to copy
- *  @return  number of chars copied
- */
-PRInt32 Left(nsString1& aCopy,PRInt32 aCount) const;
-
-/*
- *  Copies n characters from this string to given string,
- *  starting at the given offset.
- *  
- *  
- *  @param   aCopy -- Receiving string
- *  @param   aCount -- number of chars to copy
- *  @param   anOffset -- position where copying begins
- *  @return  number of chars copied
- */
-PRInt32 Mid(nsString1& aCopy,PRInt32 anOffset,PRInt32 aCount) const;
-
-/*
- *  Copies n characters from this string to given string,
- *  starting at rightmost char.
- *  
- *  
- *  @param  aCopy -- Receiving string
- *  @param  aCount -- number of chars to copy
- *  @return number of chars copied
- */
-PRInt32 Right(nsString1& aCopy,PRInt32 aCount) const;
-
-/*
- *  This method inserts n chars from given string into this
- *  string at str[anOffset].
- *  
- *  @param  aCopy -- String to be inserted into this
- *  @param  anOffset -- insertion position within this str
- *  @param  aCount -- number of chars to be copied from aCopy
- *  @return number of chars inserted into this.
- */
-PRInt32 Insert(const nsString1& aCopy,PRInt32 anOffset,PRInt32 aCount=-1);
-
-/**
- * Insert a single unicode char into this string at
- * a specified offset.
- *
- * @param   aChar char to be inserted into this string
- * @param   anOffset is insert pos in str 
- * @return  the number of chars inserted into this string
- */
-PRInt32 Insert(PRUnichar aChar,PRInt32 anOffset);
-
-/*
- *  This method is used to cut characters in this string
- *  starting at anOffset, continuing for aCount chars.
- *  
- *  @param  anOffset -- start pos for cut operation
- *  @param  aCount -- number of chars to be cut
- *  @return *this
- */
-nsString1& Cut(PRInt32 anOffset,PRInt32 aCount);
-
-/**
- *  This method is used to remove all occurances of the
- *  characters found in aSet from this string.
- *  
- *  @param  aSet -- characters to be cut from this
- *  @return *this 
- */
-nsString1& StripChars(const char* aSet);
-
-/**
- *  This method is used to replace all occurances of the
- *  given source char with the given dest char
- *  
- *  @param  
- *  @return *this 
- */
-nsString1& ReplaceChar(PRUnichar aSourceChar, PRUnichar aDestChar);
-
-/**
- *  This method strips whitespace throughout the string
- *  
- *  @return  this
- */
-nsString1& StripWhitespace();
-
-/**
- *  This method trims characters found in aTrimSet from
- *  either end of the underlying string.
- *  
- *  @param   aTrimSet -- contains chars to be trimmed from
- *           both ends
- *  @return  this
- */
-nsString1& Trim(const char* aSet,
-               PRBool aEliminateLeading=PR_TRUE,
-               PRBool aEliminateTrailing=PR_TRUE);
-
-/**
- *  This method strips whitespace from string.
- *  You can control whether whitespace is yanked from
- *  start and end of string as well.
- *  
- *  @param   aEliminateLeading controls stripping of leading ws
- *  @param   aEliminateTrailing controls stripping of trailing ws
- *  @return  this
- */
-nsString1& CompressWhitespace( PRBool aEliminateLeading=PR_TRUE,
-                              PRBool aEliminateTrailing=PR_TRUE);
-
-/**
- *  Determine if given char is a valid space character
- *  
- *  @param   aChar is character to be tested
- *  @return  TRUE if is valid space char
- */
-static  PRBool IsSpace(PRUnichar ch);
-
-/**
- *  Determine if given char in valid alpha range
- *  
- *  @param   aChar is character to be tested
- *  @return  TRUE if in alpha range
- */
-static  PRBool IsAlpha(PRUnichar ch);
-
-/**
- *  Determine if given char is valid digit
- *  
- *  @param   aChar is character to be tested
- *  @return  TRUE if char is a valid digit
- */
-static  PRBool IsDigit(PRUnichar ch);
-
-/**********************************************************************
-  Searching methods...                
- *********************************************************************/
- 
-/**
- *  Search for given character within this string.
- *  This method does so by using a binary search,
- *  so your string HAD BETTER BE ORDERED!
- *  
- *  @param   aChar is the unicode char to be found
- *  @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 BinarySearch(PRUnichar aChar) const;
-
-/**
- *  Search for given substring within this string
- *  
- *  @param   aString is substring to be sought in this
- *  @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 Find(const char* aString) const;
-PRInt32 Find(const PRUnichar* aString) const;
-PRInt32 Find(const nsString1& aString) const;
-
-/**
- *  Search for given char within this string
- *  
- *  @param   aChar - char to be found
- *  @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 Find(PRUnichar aChar,PRInt32 offset=0) const;
-
-/**
- * This method searches this string for the first character
- * found in the given string
- * @param aString contains set of chars to be found
- * @param anOffset tells us where to start searching in this
- * @return -1 if not found, else the offset in this
- */
-PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=0) const;
-PRInt32 FindCharInSet(nsString1& aString,PRInt32 anOffset=0) const;
-
-/**
- * This method searches this string for the last character
- * found in the given string
- * @param aString contains set of chars to be found
- * @param anOffset tells us where to start searching in this
- * @return -1 if not found, else the offset in this
- */
-PRInt32 RFindCharInSet(const char* aString,PRInt32 anOffset=0) const;
-PRInt32 RFindCharInSet(nsString1& aString,PRInt32 anOffset=0) const;
-
-
-/**
- * This methods scans the string backwards, looking for the given string
- * @param   aString is substring to be sought in this
- * @param   aIgnoreCase tells us whether or not to do caseless compare
- * @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 RFind(const nsString1& aString,PRBool aIgnoreCase=PR_FALSE) const;
-
-/**
- * This methods scans the string backwards, looking for the given char
- * @param   char is the char to be sought in this
- * @param   aIgnoreCase tells us whether or not to do caseless compare
- * @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 RFind(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE) const;
-
-/**********************************************************************
-  Comparison methods...                
- *********************************************************************/
-
-/**
- * Compares a given string type to this string. 
- * @update	gess 7/27/98
- * @param   S is the string to be compared
- * @param   aIgnoreCase tells us how to treat case
- * @return  -1,0,1
- */
-virtual PRInt32 Compare(const nsString1 &aString,PRBool aIgnoreCase=PR_FALSE) const;
-virtual PRInt32 Compare(const char *aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
-virtual PRInt32 Compare(const PRUnichar *aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
-
-/**
- * These methods compare a given string type to this one
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator==(const nsString1 &aString) const;
-PRBool  operator==(const char *aString) const;
-PRBool  operator==(const PRUnichar* aString) const;
-PRBool  operator==(PRUnichar* aString) const;
-
-/**
- * These methods perform a !compare of a given string type to this 
- * @param aString is the string to be compared to this
- * @return  TRUE 
- */
-PRBool  operator!=(const nsString1 &aString) const;
-PRBool  operator!=(const char *aString) const;
-PRBool  operator!=(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is < than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator<(const nsString1 &aString) const;
-PRBool  operator<(const char *aString) const;
-PRBool  operator<(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is > than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator>(const nsString1 &S) const;
-PRBool  operator>(const char *aCString) const;
-PRBool  operator>(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is <= than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator<=(const nsString1 &S) const;
-PRBool  operator<=(const char *aCString) const;
-PRBool  operator<=(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is >= than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator>=(const nsString1 &S) const;
-PRBool  operator>=(const char* aCString) const;
-PRBool  operator>=(const PRUnichar* aString) const;
-
-/**
- * Compare this to given string; note that we compare full strings here.
- * The optional length argument just lets us know how long the given string is.
- * If you provide a length, it is compared to length of this string as an
- * optimization.
- * 
- * @param  aString -- the string to compare to this
- * @param  aLength -- optional length of given string.
- * @return TRUE if equal
- */
-PRBool  Equals(const nsString1& aString) const;
-PRBool  Equals(const char* aString,PRInt32 aLength=-1) const;   
-PRBool  Equals(const nsIAtom *aAtom) const;
-
-
-/**
- * Compares to unichar string ptrs to each other
- * @param s1 is a ptr to a unichar buffer
- * @param s2 is a ptr to a unichar buffer
- * @return  TRUE if they match
- */
-PRBool  Equals(const PRUnichar* s1, const PRUnichar* s2) const;
-
-/**
- * Compare this to given string; note that we compare full strings here.
- * The optional length argument just lets us know how long the given string is.
- * If you provide a length, it is compared to length of this string as an
- * optimization.
- * 
- * @param  aString -- the string to compare to this
- * @param  aLength -- optional length of given string.
- * @return TRUE if equal
- */
-PRBool  EqualsIgnoreCase(const nsString1& aString) const;
-PRBool  EqualsIgnoreCase(const char* aString,PRInt32 aLength=-1) const;
-PRBool  EqualsIgnoreCase(const nsIAtom *aAtom) const;
-
-/**
- * Compares to unichar string ptrs to each other without respect to case
- * @param s1 is a ptr to a unichar buffer
- * @param s2 is a ptr to a unichar buffer
- * @return  TRUE if they match
- */
-PRBool  EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const;
-
-
-static void   SelfTest();
-virtual void          DebugDump(ostream& aStream) const;
-
-  protected:
-
-typedef PRUnichar chartype;
-
-            chartype*       mStr;
-            PRInt32         mLength;
-            PRInt32         mCapacity;
-#ifdef  RICKG_DEBUG
-		static	PRBool					mSelfTested;
-#endif
-};
-
-ostream& operator<<(ostream& os,nsString1& aString);
-extern NS_COM int fputs(const nsString1& aString, FILE* out);
-
-//----------------------------------------------------------------------
-
-/**
- * A version of nsString1 which is designed to be used as an automatic
- * variable.  It attempts to operate out of a fixed size internal
- * buffer until too much data is added; then a dynamic buffer is
- * allocated and grown as necessary.
- */
-// XXX template this with a parameter for the size of the buffer?
-class NS_COM nsAutoString1 : public nsString1 {
-public:
-                nsAutoString1();
-                nsAutoString1(const nsString1& other);
-                nsAutoString1(const nsAutoString1& other);
-                nsAutoString1(PRUnichar aChar);
-                nsAutoString1(const char* aCString);
-                nsAutoString1(const PRUnichar* us, PRInt32 uslen = -1);
-  virtual       ~nsAutoString1();
-
-  nsAutoString1& operator=(const nsString1& aString) {nsString1::operator=(aString); return *this;}
-  nsAutoString1& operator=(const nsAutoString1& aString) {nsString1::operator=(aString); return *this;}
-  nsAutoString1& operator=(const char* aCString) {nsString1::operator=(aCString); return *this;}
-  nsAutoString1& operator=(char aChar) {nsString1::operator=(aChar); return *this;}
-  nsAutoString1& operator=(const PRUnichar* aBuffer) {nsString1::operator=(aBuffer); return *this;}
-  nsAutoString1& operator=(PRUnichar aChar) {nsString1::operator=(aChar); return *this;}
-
-  virtual void  SizeOf(nsISizeOfHandler* aHandler) const;
-
-  static  void  SelfTest();
-
-protected:
-  virtual void EnsureCapacityFor(PRInt32 aNewLength);
-
-  chartype mBuf[32];
-};
-
-ostream& operator<<(ostream& os,nsAutoString1& aString);
-
-#endif
-

mozilla/string/obsolete/nsString2.h

@@ -1,827 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-/***********************************************************************
-  MODULE NOTES:
-
-  This version of the nsString class offers many improvements over the
-  original version:
-    1. Wide and narrow chars
-    2. Allocators
-    3. Much smarter autostrings
-    4. Subsumable strings
-    5. Memory pools and recycling
- ***********************************************************************/
-
-
-#ifndef _nsString2
-#define _nsString2
-
-#include "prtypes.h"
-#include "nscore.h"
-#include <iostream.h>
-#include <stdio.h>
-#include "nsCRT.h"
-
-#include "nsStr.h"
-#include <iostream.h>
-#include <stdio.h>
-#include "nsIAtom.h"
-
-class nsISizeOfHandler;
-
-
-#define nsString2     nsString
-#define nsAutoString2 nsAutoString
-
-#define kRadix10        (10)
-#define kRadix16        (16)
-#define kAutoDetect     (100)
-#define kRadixUnknown   (kAutoDetect+1)
-
-
-class NS_COM nsSubsumeStr;
-class NS_COM nsString2 : public nsStr {
-
-  public: 
-
-/**
- * Default constructor. Note that we actually allocate a small buffer
- * to begin with. This is because the "philosophy" of the string class
- * was to allow developers direct access to the underlying buffer for
- * performance reasons. 
- */
-nsString2(eCharSize aCharSize=kDefaultCharSize,nsIMemoryAgent* anAgent=0);
-
-
-/**
- * This constructor accepts an isolatin string
- * @param   aCString is a ptr to a 1-byte cstr
- */
-nsString2(const char* aCString,eCharSize aCharSize=kDefaultCharSize,nsIMemoryAgent* anAgent=0);
-
-/**
- * This constructor accepts a unichar string
- * @param   aCString is a ptr to a 2-byte cstr
- */
-nsString2(const PRUnichar* aString,eCharSize aCharSize=kDefaultCharSize,nsIMemoryAgent* anAgent=0);
-
-/**
- * This is a copy constructor that accepts an nsStr
- * @param   reference to another nsString2
- */
-nsString2(const nsStr&,eCharSize aCharSize=kDefaultCharSize,nsIMemoryAgent* anAgent=0);
-
-/**
- * This is our copy constructor 
- * @param   reference to another nsString2
- */
-nsString2(const nsString2& aString);   
-
-/**
- * This constructor takes a subsumestr
- * @param   reference to subsumestr
- */
-nsString2(nsSubsumeStr& aSubsumeStr);   
-
-/**
- * Destructor
- * 
- */
-virtual ~nsString2();    
-
-/**
- * Retrieve the length of this string
- * @return string length
- */
-inline PRInt32 Length() const { return (PRInt32)mLength; }
-
-/**
- * Retrieve the size of this string
- * @return string length
- */
-virtual void SizeOf(nsISizeOfHandler* aHandler) const;
-
-
-/**
- * Call this method if you want to force a different string capacity
- * @update	gess7/30/98
- * @param   aLength -- contains new length for mStr
- * @return
- */
-void SetLength(PRUint32 aLength) { 
-  SetCapacity(aLength);
-}
-
-/**
- * Sets the new length of the string.
- * @param   aLength is new string length.
- * @return  nada
- */
-void SetCapacity(PRUint32 aLength);
-/**
- * This method truncates this string to given length.
- *
- * @param   anIndex -- new length of string
- * @return  nada
- */
-void Truncate(PRInt32 anIndex=0);
-
-
-/**
- *  Determine whether or not the characters in this
- *  string are in sorted order.
- *  
- *  @return  TRUE if ordered.
- */
-PRBool IsOrdered(void) const;
-
-/**
- *  Determine whether or not the characters in this
- *  string are in store as 1 or 2 byte (unicode) strings.
- *  
- *  @return  TRUE if ordered.
- */
-PRBool IsUnicode(void) const {
-  PRBool result=PRBool(mCharSize==eTwoByte);
-  return result;
-}
-
-/**
- *  Determine whether or not this string has a length of 0
- *  
- *  @return  TRUE if empty.
- */
-PRBool IsEmpty(void) const {
-  return PRBool(0==mLength);
-}
-
-/**********************************************************************
-  Accessor methods...
- *********************************************************************/
-
-const char* GetBuffer(void) const;
-const PRUnichar* GetUnicode(void) const;
-
-
- /**
-   * Get nth character.
-   */
-PRUnichar operator[](PRUint32 anIndex) const;
-PRUnichar CharAt(PRUint32 anIndex) const;
-PRUnichar First(void) const;
-PRUnichar Last(void) const;
-
-PRBool SetCharAt(PRUnichar aChar,PRUint32 anIndex);
-
-
-/**********************************************************************
-  String creation methods...
- *********************************************************************/
-
-/**
- * Create a new string by appending given string to this
- * @param   aString -- 2nd string to be appended
- * @return  new string
- */
-nsSubsumeStr operator+(const nsStr& aString);
-
-/**
- * Create a new string by appending given string to this
- * @param   aString -- 2nd string to be appended
- * @return  new string
- */
-nsSubsumeStr operator+(const nsString2& aString);
-
-/**
- * create a new string by adding this to the given buffer.
- * @param   aCString is a ptr to cstring to be added to this
- * @return  newly created string
- */
-nsSubsumeStr operator+(const char* aCString);
-
-/**
- * create a new string by adding this to the given wide buffer.
- * @param   aString is a ptr to UC-string to be added to this
- * @return  newly created string
- */
-nsSubsumeStr operator+(const PRUnichar* aString);
-
-/**
- * create a new string by adding this to the given char.
- * @param   aChar is a char to be added to this
- * @return  newly created string
- */
-nsSubsumeStr operator+(char aChar);
-
-/**
- * create a new string by adding this to the given char.
- * @param   aChar is a unichar to be added to this
- * @return  newly created string
- */
-nsSubsumeStr operator+(PRUnichar aChar);
-
-/**********************************************************************
-  Lexomorphic transforms...
- *********************************************************************/
-
-/**
- * Converts all chars in given string to UCS2
- * which ensure that the lower 256 chars are correct.
- */
-void ToUCS2(PRUint32 aStartOffset);
-
-/**
- * Converts chars in this to lowercase
- * @update	gess 7/27/98
- */
-void ToLowerCase();
-
-
-/**
- * Converts chars in this to lowercase, and
- * stores them in aOut
- * @update	gess 7/27/98
- * @param   aOut is a string to contain result
- */
-void ToLowerCase(nsString2& aString) const;
-
-/**
- * Converts chars in this to uppercase
- * @update	gess 7/27/98
- */
-void ToUpperCase();
-
-/**
- * Converts chars in this to lowercase, and
- * stores them in a given output string
- * @update	gess 7/27/98
- * @param   aOut is a string to contain result
- */
-void ToUpperCase(nsString2& aString) const;
-
-
-/**
- *  This method is used to remove all occurances of the
- *  characters found in aSet from this string.
- *  
- *  @param  aSet -- characters to be cut from this
- *  @return *this 
- */
-nsString2& StripChars(const char* aSet);
-
-/**
- *  This method strips whitespace throughout the string
- *  
- *  @return  this
- */
-nsString2& StripWhitespace();
-
-/**
- *  swaps occurence of 1 string for another
- *  
- *  @return  this
- */
-nsString2& ReplaceChar(PRUnichar aSourceChar,PRUnichar aDestChar);
-
-/**
- *  This method trims characters found in aTrimSet from
- *  either end of the underlying string.
- *  
- *  @param   aTrimSet -- contains chars to be trimmed from
- *           both ends
- *  @return  this
- */
-nsString2& Trim(const char* aSet,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
-
-/**
- *  This method strips whitespace from string.
- *  You can control whether whitespace is yanked from
- *  start and end of string as well.
- *  
- *  @param   aEliminateLeading controls stripping of leading ws
- *  @param   aEliminateTrailing controls stripping of trailing ws
- *  @return  this
- */
-nsString2& CompressSet(const char* aSet, char aChar, PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
-
-/**
- *  This method strips whitespace from string.
- *  You can control whether whitespace is yanked from
- *  start and end of string as well.
- *  
- *  @param   aEliminateLeading controls stripping of leading ws
- *  @param   aEliminateTrailing controls stripping of trailing ws
- *  @return  this
- */
-nsString2& CompressWhitespace( PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
-
-/**********************************************************************
-  string conversion methods...
- *********************************************************************/
-
-/**
- * This method constructs a new nsString2 on the stack that is a copy
- * of this string.
- * 
- */
-nsString2* ToNewString() const;
-
-/**
- * Creates an ISOLatin1 clone of this string
- * @return  ptr to new isolatin1 string
- */
-char* ToNewCString() const;
-
-/**
- * Creates a unicode clone of this string
- * @return  ptr to new unicode string
- */
-PRUnichar* ToNewUnicode() const;
-
-/**
- * Copies data from internal buffer onto given char* buffer
- * @param aBuf is the buffer where data is stored
- * @param aBuflength is the max # of chars to move to buffer
- * @return ptr to given buffer
- */
-char* ToCString(char* aBuf,PRUint32 aBufLength,PRUint32 anOffset=0) const;
-
-/**
- * Perform string to float conversion.
- * @param   aErrorCode will contain error if one occurs
- * @return  float rep of string value
- */
-float ToFloat(PRInt32* aErrorCode) const;
-
-/**
- * Try to derive the radix from the value contained in this string
- * @return  kRadix10, kRadix16 or kAutoDetect (meaning unknown)
- */
-PRUint32  DetermineRadix(void);
-
-/**
- * Perform string to int conversion.
- * @param   aErrorCode will contain error if one occurs
- * @return  int rep of string value
- */
-PRInt32   ToInteger(PRInt32* aErrorCode,PRUint32 aRadix=kRadix10) const;
-
-
-/**********************************************************************
-  String manipulation methods...                
- *********************************************************************/
-
-/**
- * Functionally equivalent to assign or operator=
- * 
- */
-nsString2& SetString(const char* aString,PRInt32 aLength=-1) {return Assign(aString,aLength);}
-nsString2& SetString(const PRUnichar* aString,PRInt32 aLength=-1) {return Assign(aString,aLength);}
-nsString2& SetString(const nsString2& aString,PRInt32 aLength=-1) {return Assign(aString,aLength);}
-
-/**
- * assign given string to this string
- * @param   aStr: buffer to be assigned to this 
- * @param   alength is the length of the given str (or -1)
-            if you want me to determine its length
- * @return  this
- */
-nsString2& Assign(const nsString2& aString,PRInt32 aCount=-1);
-nsString2& Assign(const nsStr& aString,PRInt32 aCount=-1);
-nsString2& Assign(const char* aString,PRInt32 aCount=-1);
-nsString2& Assign(const PRUnichar* aString,PRInt32 aCount=-1);
-nsString2& Assign(char aChar);
-nsString2& Assign(PRUnichar aChar);
-
-/**
- * here come a bunch of assignment operators...
- * @param   aString: string to be added to this
- * @return  this
- */
-nsString2& operator=(const nsString2& aString) {return Assign(aString);}
-nsString2& operator=(const nsStr& aString) {return Assign(aString);}
-nsString2& operator=(char aChar) {return Assign(aChar);}
-nsString2& operator=(PRUnichar aChar) {return Assign(aChar);}
-nsString2& operator=(const char* aCString) {return Assign(aCString);}
-nsString2& operator=(const PRUnichar* aString) {return Assign(aString);}
-#ifdef AIX
-nsString2& operator=(const nsSubsumeStr& aSubsumeString);  // AIX requires a const here
-#else
-nsString2& operator=(nsSubsumeStr& aSubsumeString);
-#endif
-
-/**
- * Here's a bunch of append mehtods for varying types...
- * @param   aString : string to be appended to this
- * @return  this
- */
-nsString2& operator+=(const nsStr& aString){return Append(aString,aString.mLength);}
-nsString2& operator+=(const nsString2& aString){return Append(aString,aString.mLength);}
-nsString2& operator+=(const char* aCString) {return Append(aCString);}
-//nsString2& operator+=(char aChar){return Append(aChar);}
-nsString2& operator+=(const PRUnichar* aUCString) {return Append(aUCString);}
-nsString2& operator+=(PRUnichar aChar){return Append(aChar);}
-
-/*
- *  Appends n characters from given string to this,
- *  This version computes the length of your given string
- *  
- *  @param   aString is the source to be appended to this
- *  @return  number of chars copied
- */
-nsString2& Append(const nsStr& aString) {return Append(aString,aString.mLength);}
-nsString2& Append(const nsString2& aString) {return Append(aString,aString.mLength);}
- 
-
-/*
- *  Appends n characters from given string to this,
- *  
- *  @param   aString is the source to be appended to this
- *  @param   aCount -- number of chars to copy
- *  @return  number of chars copied
- */
-nsString2& Append(const nsStr& aString,PRInt32 aCount);
-nsString2& Append(const nsString2& aString,PRInt32 aCount);
-nsString2& Append(const char* aString,PRInt32 aCount=-1);
-nsString2& Append(const PRUnichar* aString,PRInt32 aCount=-1);
-nsString2& Append(char aChar);
-nsString2& Append(PRUnichar aChar);
-nsString2& Append(PRInt32 aInteger,PRInt32 aRadix=10); //radix=8,10 or 16
-nsString2& Append(float aFloat);
-             
-/*
- *  Copies n characters from this string to given string,
- *  starting at the leftmost offset.
- *  
- *  
- *  @param   aCopy -- Receiving string
- *  @param   aCount -- number of chars to copy
- *  @return  number of chars copied
- */
-PRUint32 Left(nsString2& aCopy,PRInt32 aCount) const;
-
-/*
- *  Copies n characters from this string to given string,
- *  starting at the given offset.
- *  
- *  
- *  @param   aCopy -- Receiving string
- *  @param   aCount -- number of chars to copy
- *  @param   anOffset -- position where copying begins
- *  @return  number of chars copied
- */
-PRUint32 Mid(nsString2& aCopy,PRUint32 anOffset,PRInt32 aCount) const;
-
-/*
- *  Copies n characters from this string to given string,
- *  starting at rightmost char.
- *  
- *  
- *  @param  aCopy -- Receiving string
- *  @param  aCount -- number of chars to copy
- *  @return number of chars copied
- */
-PRUint32 Right(nsString2& aCopy,PRInt32 aCount) const;
-
-/*
- *  This method inserts n chars from given string into this
- *  string at str[anOffset].
- *  
- *  @param  aCopy -- String to be inserted into this
- *  @param  anOffset -- insertion position within this str
- *  @param  aCount -- number of chars to be copied from aCopy
- *  @return number of chars inserted into this.
- */
-nsString2& Insert(const nsString2& aCopy,PRUint32 anOffset,PRInt32 aCount=-1);
-
-/**
- * Insert a given string into this string at
- * a specified offset.
- *
- * @param   aString* to be inserted into this string
- * @param   anOffset is insert pos in str 
- * @return  the number of chars inserted into this string
- */
-nsString2& Insert(const char* aChar,PRUint32 anOffset,PRInt32 aCount=-1);
-nsString2& Insert(const PRUnichar* aChar,PRUint32 anOffset,PRInt32 aCount=-1);
-
-/**
- * Insert a single char into this string at
- * a specified offset.
- *
- * @param   character to be inserted into this string
- * @param   anOffset is insert pos in str 
- * @return  the number of chars inserted into this string
- */
-//nsString2& Insert(char aChar,PRUint32 anOffset);
-nsString2& Insert(PRUnichar aChar,PRUint32 anOffset);
-
-/*
- *  This method is used to cut characters in this string
- *  starting at anOffset, continuing for aCount chars.
- *  
- *  @param  anOffset -- start pos for cut operation
- *  @param  aCount -- number of chars to be cut
- *  @return *this
- */
-nsString2& Cut(PRUint32 anOffset,PRInt32 aCount);
-
-
-/**********************************************************************
-  Searching methods...                
- *********************************************************************/
- 
-/**
- *  Search for given character within this string.
- *  This method does so by using a binary search,
- *  so your string HAD BETTER BE ORDERED!
- *  
- *  @param   aChar is the unicode char to be found
- *  @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 BinarySearch(PRUnichar aChar) const;
-
-/**
- *  Search for given substring within this string
- *  
- *  @param   aString is substring to be sought in this
- *  @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 Find(const nsString2& aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 Find(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 Find(const char* aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 Find(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 Find(PRUnichar aChar,PRUint32 offset=0,PRBool aIgnoreCase=PR_FALSE) const;
-
-/**
- * This method searches this string for the first character
- * found in the given string
- * @param aString contains set of chars to be found
- * @param anOffset tells us where to start searching in this
- * @return -1 if not found, else the offset in this
- */
-PRInt32 FindCharInSet(const char* aString,PRUint32 anOffset=0) const;
-PRInt32 FindCharInSet(const PRUnichar* aString,PRUint32 anOffset=0) const;
-PRInt32 FindCharInSet(const nsString2& aString,PRUint32 anOffset=0) const;
-
-/**
- * This method searches this string for the last character
- * found in the given string
- * @param aString contains set of chars to be found
- * @param anOffset tells us where to start searching in this
- * @return -1 if not found, else the offset in this
- */
-PRInt32 RFindCharInSet(const char* aString,PRUint32 anOffset=0) const;
-PRInt32 RFindCharInSet(const PRUnichar* aString,PRUint32 anOffset=0) const;
-PRInt32 RFindCharInSet(const nsString2& aString,PRUint32 anOffset=0) const;
-
-
-/**
- * This methods scans the string backwards, looking for the given string
- * @param   aString is substring to be sought in this
- * @param   aIgnoreCase tells us whether or not to do caseless compare
- * @return  offset in string, or -1 (kNotFound)
- */
-PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 RFind(const nsString2& aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 RFind(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRInt32 RFind(PRUnichar aChar,PRUint32 offset=0,PRBool aIgnoreCase=PR_FALSE) const;
-
-/**********************************************************************
-  Comparison methods...                
- *********************************************************************/
-
-/**
- * Compares a given string type to this string. 
- * @update	gess 7/27/98
- * @param   S is the string to be compared
- * @param   aIgnoreCase tells us how to treat case
- * @return  -1,0,1
- */
-virtual PRInt32 Compare(const nsString2& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
-virtual PRInt32 Compare(const nsStr &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
-virtual PRInt32 Compare(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
-virtual PRInt32 Compare(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aLength=-1) const;
-
-/**
- * These methods compare a given string type to this one
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator==(const nsString2 &aString) const;
-PRBool  operator==(const nsStr &aString) const;
-PRBool  operator==(const char *aString) const;
-PRBool  operator==(const PRUnichar* aString) const;
-
-/**
- * These methods perform a !compare of a given string type to this 
- * @param aString is the string to be compared to this
- * @return  TRUE 
- */
-PRBool  operator!=(const nsString2 &aString) const;
-PRBool  operator!=(const nsStr &aString) const;
-PRBool  operator!=(const char* aString) const;
-PRBool  operator!=(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is < than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator<(const nsString2 &aString) const;
-PRBool  operator<(const nsStr &aString) const;
-PRBool  operator<(const char* aString) const;
-PRBool  operator<(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is > than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator>(const nsString2 &aString) const;
-PRBool  operator>(const nsStr &S) const;
-PRBool  operator>(const char* aString) const;
-PRBool  operator>(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is <= than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator<=(const nsString2 &aString) const;
-PRBool  operator<=(const nsStr &S) const;
-PRBool  operator<=(const char* aString) const;
-PRBool  operator<=(const PRUnichar* aString) const;
-
-/**
- * These methods test if a given string is >= than this
- * @param aString is the string to be compared to this
- * @return  TRUE or FALSE
- */
-PRBool  operator>=(const nsString2 &aString) const;
-PRBool  operator>=(const nsStr &S) const;
-PRBool  operator>=(const char* aString) const;
-PRBool  operator>=(const PRUnichar* aString) const;
-
-/**
- * Compare this to given string; note that we compare full strings here.
- * The optional length argument just lets us know how long the given string is.
- * If you provide a length, it is compared to length of this string as an
- * optimization.
- * 
- * @param  aString -- the string to compare to this
- * @param  aLength -- optional length of given string.
- * @return TRUE if equal
- */
-PRBool  Equals(const nsString2 &aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRBool  Equals(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRBool  Equals(const char* aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRBool  Equals(const char* aString,PRUint32 aCount,PRBool aIgnoreCase) const;   
-PRBool  Equals(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE) const;
-PRBool  Equals(const PRUnichar* aString,PRUint32 aCount,PRBool aIgnoreCase) const;   
-PRBool  Equals(const nsIAtom* anAtom,PRBool aIgnoreCase) const;   
-PRBool  Equals(const PRUnichar* s1, const PRUnichar* s2,PRBool aIgnoreCase=PR_FALSE) const;
-
-PRBool  EqualsIgnoreCase(const nsString2& aString) const;
-PRBool  EqualsIgnoreCase(const char* aString,PRInt32 aLength=-1) const;
-PRBool  EqualsIgnoreCase(const nsIAtom *aAtom) const;
-PRBool  EqualsIgnoreCase(const PRUnichar* s1, const PRUnichar* s2) const;
-
-
-/**
- *  Determine if given char is a valid space character
- *  
- *  @param   aChar is character to be tested
- *  @return  TRUE if is valid space char
- */
-static  PRBool IsSpace(PRUnichar ch);
-
-/**
- *  Determine if given char in valid alpha range
- *  
- *  @param   aChar is character to be tested
- *  @return  TRUE if in alpha range
- */
-static  PRBool IsAlpha(PRUnichar ch);
-
-/**
- *  Determine if given char is valid digit
- *  
- *  @param   aChar is character to be tested
- *  @return  TRUE if char is a valid digit
- */
-static  PRBool IsDigit(PRUnichar ch);
-
-static  void        Recycle(nsString2* aString);
-static  nsString2*  CreateString(eCharSize aCharSize=eTwoByte);
-
-virtual void  DebugDump(ostream& aStream) const;
-
-  nsIMemoryAgent* mAgent;
-
-};
-
-extern NS_COM int fputs(const nsString2& aString, FILE* out);
-ostream& operator<<(ostream& aStream,const nsString2& aString);
-
-
-/**************************************************************
-  Here comes the AutoString class which uses internal memory
-  (typically found on the stack) for its default buffer.
-  If the buffer needs to grow, it gets reallocated on the heap.
- **************************************************************/
-
-class NS_COM nsAutoString2 : public nsString2 {
-public: 
-
-    nsAutoString2(eCharSize aCharSize=kDefaultCharSize);
-    nsAutoString2(nsStr& anExtBuffer,const char* aCString);
-
-
-    nsAutoString2(const char* aCString,eCharSize aCharSize=kDefaultCharSize);
-    nsAutoString2(char* aCString,PRInt32 aCapacity=-1,eCharSize aCharSize=kDefaultCharSize,PRBool assumeOwnership=PR_FALSE);
-    nsAutoString2(const PRUnichar* aString,eCharSize aCharSize=kDefaultCharSize);
-    nsAutoString2(PRUnichar* aString,PRInt32 aCapacity=-1,eCharSize aCharSize=kDefaultCharSize,PRBool assumeOwnership=PR_FALSE);
-    
-    nsAutoString2(const nsStr& aString,eCharSize aCharSize=kDefaultCharSize);
-    nsAutoString2(const nsString2& aString,eCharSize aCharSize=kDefaultCharSize);
-    nsAutoString2(const nsAutoString2& aString,eCharSize aCharSize=kDefaultCharSize);
-#ifdef AIX
-    nsAutoString2(const nsSubsumeStr& aSubsumeStr);  // AIX requires a const
-#else
-    nsAutoString2(nsSubsumeStr& aSubsumeStr);
-#endif // AIX
-    nsAutoString2(PRUnichar aChar,eCharSize aCharSize=kDefaultCharSize);
-    virtual ~nsAutoString2();
-
-    nsAutoString2& operator=(const nsString2& aString) {nsString2::operator=(aString); return *this;}
-    nsAutoString2& operator=(const nsStr& aString) {nsString2::Assign(aString); return *this;}
-    nsAutoString2& operator=(const nsAutoString2& aString) {nsString2::operator=(aString); return *this;}
-    nsAutoString2& operator=(const char* aCString) {nsString2::operator=(aCString); return *this;}
-    nsAutoString2& operator=(char aChar) {nsString2::operator=(aChar); return *this;}
-    nsAutoString2& operator=(const PRUnichar* aBuffer) {nsString2::operator=(aBuffer); return *this;}
-    nsAutoString2& operator=(PRUnichar aChar) {nsString2::operator=(aChar); return *this;}
-
-    /**
-     * Retrieve the size of this string
-     * @return string length
-     */
-    virtual void SizeOf(nsISizeOfHandler* aHandler) const;
-    
-    char mBuffer[32];
-};
-
-
-/***************************************************************
-  The subsumestr class is very unusual. 
-  It differs from a normal string in that it doesn't use normal
-  copy semantics when another string is assign to this. 
-  Instead, it "steals" the contents of the source string.
-
-  This is very handy for returning nsString classes as part of
-  an operator+(...) for example, in that it cuts down the number
-  of copy operations that must occur. 
-
-  You should probably not use this class unless you really know
-  what you're doing.
- ***************************************************************/
-class NS_COM nsSubsumeStr : public nsString2 {
-public:
-  nsSubsumeStr(nsString2& aString);
-  nsSubsumeStr(nsStr& aString);
-  nsSubsumeStr(PRUnichar* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
-  nsSubsumeStr(char* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
-};
-
-
-/***************************************************************
-
- ***************************************************************/
-class NS_COM nsCAutoString: public nsAutoString{
-public:
-  nsCAutoString(const nsString2& aString);
-  operator const char*() const;
-};
-
-
-#endif
-
-

mozilla/string/obsolete/nsXPIDLString.cpp

@@ -1,167 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsDebug.h"
-#include "nsIAllocator.h"
-#include "nsXPIDLString.h"
-#include "plstr.h"
-
-// If the allocator changes, fix it here.
-#define XPIDL_STRING_ALLOC(__len)  ((PRUnichar*) nsAllocator::Alloc((__len) * sizeof(PRUnichar)))
-#define XPIDL_CSTRING_ALLOC(__len) ((char*) nsAllocator::Alloc((__len) * sizeof(char)))
-#define XPIDL_FREE(__ptr)          (nsAllocator::Free(__ptr))
-
-////////////////////////////////////////////////////////////////////////
-// nsXPIDLString
-
-nsXPIDLString::nsXPIDLString()
-    : mBufOwner(PR_FALSE),
-      mBuf(0)
-{
-}
-
-
-nsXPIDLString::~nsXPIDLString()
-{
-    if (mBufOwner && mBuf)
-        XPIDL_FREE(mBuf);
-}
-
-
-nsXPIDLString::operator const PRUnichar*()
-{
-    return mBuf;
-}
-
-
-PRUnichar*
-nsXPIDLString::Copy(const PRUnichar* aString)
-{
-    NS_ASSERTION(aString, "null ptr");
-    if (! aString)
-        return 0;
-
-    PRInt32 len = 0;
-
-    {
-        const PRUnichar* p = aString;
-        while (*p++)
-            len++;
-    }
-
-    PRUnichar* result = XPIDL_STRING_ALLOC(len + 1);
-    if (result) {
-        PRUnichar* q = result;
-        while (*aString) {
-            *q = *aString;
-            q++;
-            aString++;
-        }
-        *q = '\0';
-    }
-    return result;
-}
-
-
-PRUnichar**
-nsXPIDLString::StartAssignmentByValue()
-{
-    if (mBufOwner && mBuf)
-        XPIDL_FREE(mBuf);
-
-    mBuf = 0;
-    mBufOwner = PR_TRUE;
-    return &mBuf;
-}
-
-
-const PRUnichar**
-nsXPIDLString::StartAssignmentByReference()
-{
-    if (mBufOwner && mBuf)
-        XPIDL_FREE(mBuf);
-
-    mBuf = 0;
-    mBufOwner = PR_FALSE;
-    return (const PRUnichar**) &mBuf;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-// nsXPIDLCString
-
-nsXPIDLCString::nsXPIDLCString()
-    : mBufOwner(PR_FALSE),
-      mBuf(0)
-{
-}
-
-
-nsXPIDLCString::~nsXPIDLCString()
-{
-    if (mBufOwner && mBuf)
-        XPIDL_FREE(mBuf);
-}
-
-
-nsXPIDLCString::operator const char*()
-{
-    return mBuf;
-}
-
-
-char*
-nsXPIDLCString::Copy(const char* aCString)
-{
-    NS_ASSERTION(aCString, "null ptr");
-    if (! aCString)
-        return 0;
-
-    PRInt32 len = PL_strlen(aCString);
-    char* result = XPIDL_CSTRING_ALLOC(len + 1);
-    if (result)
-        PL_strcpy(result, aCString);
-
-    return result;
-}
-
-
-char**
-nsXPIDLCString::StartAssignmentByValue()
-{
-    if (mBufOwner && mBuf)
-        XPIDL_FREE(mBuf);
-
-    mBuf = 0;
-    mBufOwner = PR_TRUE;
-    return &mBuf;
-}
-
-
-const char**
-nsXPIDLCString::StartAssignmentByReference()
-{
-    if (mBufOwner && mBuf)
-        XPIDL_FREE(mBuf);
-
-    mBuf = 0;
-    mBufOwner = PR_FALSE;
-    return (const char**) &mBuf;
-}
-
-

mozilla/string/obsolete/nsXPIDLString.h

@@ -1,300 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-/*
-
-  A set of string wrapper classes that ease transition to use of XPIDL
-  interfaces. nsXPIDLString and nsXPIDLCString are to XPIDL `wstring'
-  and `string' out params as nsCOMPtr is to generic XPCOM interface
-  pointers. They help you deal with object ownership.
-
-  Consider the following interface:
-
-    interface nsIFoo {
-      attribute string Bar;
-    };
-
-  This will generate the following C++ header file:
-
-    class nsIFoo {
-      NS_IMETHOD SetBar(const PRUnichar* aValue);
-      NS_IMETHOD GetBar(PRUnichar* *aValue);
-    };
-
-  The GetBar() method will allocate a copy of the nsIFoo object's
-  "bar" attribute, and leave you to deal with freeing it:
-
-    nsIFoo* aFoo; // assume we get this somehow
-    PRUnichar* bar;
-    aFoo->GetFoo(&bar);
-    // Use bar here...
-    printf("bar is %s!\n", bar);
-    delete[] bar;
-
-  (Strictly speaking, the `delete[] bar' should use the proper XPCOM
-  de-allocator; we'll ignore that for now.)
-
-  This makes your life harder, because you need to convolute your code
-  to ensure that you don't leak `bar'.
-
-  Enter nsXPIDLString, which manages the ownership of the allocated
-  string, and automatically destroys it when the nsXPIDLString goes
-  out of scope:
-
-    nsIFoo* aFoo;
-    nsXPIDLString bar;
-    aFoo->GetFoo( getter_Copies(bar) );
-    // Use bar here...
-    printf("bar is %s!\n", (const char*) bar);
-    // no need to remember to delete[].
-
-  Like nsCOMPtr, nsXPIDLString uses some syntactic sugar to make it
-  painfully clear exactly what the code expects. You need to wrap an
-  nsXPIDLString object with either `getter_Copies()' or
-  `getter_Shares()' before passing it to a getter: these tell the
-  nsXPIDLString how ownership is being handled.
-
-  In the case of `getter_Copies()', the callee is allocating a copy
-  (which is usually the case). In the case of `getter_Shares()', the
-  callee is returning a const reference to `the real deal' (this can
-  be done using the [shared] attribute in XPIDL).
-
- */
-
-#ifndef nsXPIDLString_h__
-#define nsXPIDLString_h__
-
-#include "nsCom.h"
-#include "prtypes.h"
-
-#ifndef __PRUNICHAR__
-#define __PRUNICHAR__
-typedef PRUint16 PRUnichar;
-#endif /* __PRUNICHAR__ */
-
-////////////////////////////////////////////////////////////////////////
-// nsXPIDLString
-//
-//   A wrapper for Unicode strings. With the |getter_Copies()| and
-//   |getter_Shares()| helper functions, this can be used instead of
-//   the "naked" |PRUnichar*| interface for |wstring| parameters in
-//   XPIDL interfaces.
-//
-
-class NS_COM nsXPIDLString {
-private:
-    PRUnichar* mBuf;
-    PRBool     mBufOwner;
-
-    PRUnichar** StartAssignmentByValue();
-    const PRUnichar** StartAssignmentByReference();
-
-public:
-    /**
-     * Construct a new, uninitialized wrapper for a Unicode string.
-     */
-    nsXPIDLString();
-
-    virtual ~nsXPIDLString();
-
-    /**
-     * Return a reference to the immutable Unicode string.
-     */
-    operator const PRUnichar*();
-
-    /**
-     * Make a copy of the Unicode string. Use this function in the
-     * callee to ensure that the correct memory allocator is used.
-     */
-    static PRUnichar* Copy(const PRUnichar* aString);
-
-    // A helper class for assignment-by-value. This class is an
-    // implementation detail and should not be considered part of the
-    // public interface.
-    class NS_COM GetterCopies {
-    private:
-        nsXPIDLString& mXPIDLString;
-
-    public:
-        GetterCopies(nsXPIDLString& aXPIDLString)
-            : mXPIDLString(aXPIDLString) {}
-
-        operator PRUnichar**() {
-            return mXPIDLString.StartAssignmentByValue();
-        }
-
-        friend GetterCopies getter_Copies(nsXPIDLString& aXPIDLString);
-    };
-
-    friend class GetterCopies;
-
-    // A helper class for assignment-by-reference. This class is an
-    // implementation detail and should not be considered part of the
-    // public interface.
-    class NS_COM GetterShares {
-    private:
-        nsXPIDLString& mXPIDLString;
-
-    public:
-        GetterShares(nsXPIDLString& aXPIDLString)
-            : mXPIDLString(aXPIDLString) {}
-
-        operator const PRUnichar**() {
-            return mXPIDLString.StartAssignmentByReference();
-        }
-
-        friend GetterShares getter_Shares(nsXPIDLString& aXPIDLString);
-    };
-
-    friend class GetterShares;
-
-private:
-    // not to be implemented
-    nsXPIDLString(nsXPIDLString& /* aXPIDLString */) {}
-    nsXPIDLString& operator =(nsXPIDLString& /* aXPIDLString */) { return *this; }
-};
-
-
-/**
- * Use this function to "wrap" the nsXPIDLString object that is to
- * receive an |out| value.
- */
-inline nsXPIDLString::GetterCopies
-getter_Copies(nsXPIDLString& aXPIDLString)
-{
-    return nsXPIDLString::GetterCopies(aXPIDLString);
-}
-
-/**
- * Use this function to "wrap" the nsXPIDLString object that is to
- * receive a |[shared] out| value.
- */
-inline nsXPIDLString::GetterShares
-getter_Shares(nsXPIDLString& aXPIDLString)
-{
-    return nsXPIDLString::GetterShares(aXPIDLString);
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-// nsXPIDLCString
-//
-//   A wrapper for Unicode strings. With the |getter_Copies()| and
-//   |getter_Shares()| helper functions, this can be used instead of
-//   the "naked" |char*| interface for |string| parameters in XPIDL
-//   interfaces.
-//
-
-class NS_COM nsXPIDLCString {
-private:
-    char*  mBuf;
-    PRBool mBufOwner;
-
-    char** StartAssignmentByValue();
-    const char** StartAssignmentByReference();
-
-public:
-    /**
-     * Construct a new, uninitialized wrapper for a single-byte string.
-     */
-    nsXPIDLCString();
-
-    virtual ~nsXPIDLCString();
-
-    /**
-     * Return a reference to the immutable single-byte string.
-     */
-    operator const char*();
-
-    /**
-     * Make a copy of the single-byte string. Use this function in the
-     * callee to ensure that the correct memory allocator is used.
-     */
-    static char* Copy(const char* aString);
-
-    // A helper class for assignment-by-value. This class is an
-    // implementation detail and should not be considered part of the
-    // public interface.
-    class NS_COM GetterCopies {
-    private:
-        nsXPIDLCString& mXPIDLString;
-
-    public:
-        GetterCopies(nsXPIDLCString& aXPIDLString)
-            : mXPIDLString(aXPIDLString) {}
-
-        operator char**() {
-            return mXPIDLString.StartAssignmentByValue();
-        }
-
-        friend GetterCopies getter_Copies(nsXPIDLCString& aXPIDLString);
-    };
-
-    friend class GetterCopies;
-
-    // A helper class for assignment-by-reference. This class is an
-    // implementation detail and should not be considered part of the
-    // public interface.
-    class NS_COM GetterShares {
-    private:
-        nsXPIDLCString& mXPIDLString;
-
-    public:
-        GetterShares(nsXPIDLCString& aXPIDLString)
-            : mXPIDLString(aXPIDLString) {}
-
-        operator const char**() {
-            return mXPIDLString.StartAssignmentByReference();
-        }
-
-        friend GetterShares getter_Shares(nsXPIDLCString& aXPIDLString);
-    };
-
-    friend class GetterShares;
-
-private:
-    // not to be implemented
-    nsXPIDLCString(nsXPIDLCString& /* aXPIDLString */) {}
-    nsXPIDLCString& operator =(nsXPIDLCString& /* aXPIDLCString */) { return *this; }
-};
-
-/**
- * Use this function to "wrap" the nsXPIDLCString object that is to
- * receive an |out| value.
- */
-inline nsXPIDLCString::GetterCopies
-getter_Copies(nsXPIDLCString& aXPIDLString)
-{
-    return nsXPIDLCString::GetterCopies(aXPIDLString);
-}
-
-
-/**
- * Use this function to "wrap" the nsXPIDLCString object that is to
- * receive a |[shared] out| value.
- */
-inline nsXPIDLCString::GetterShares
-getter_Shares(nsXPIDLCString& aXPIDLString)
-{
-    return nsXPIDLCString::GetterShares(aXPIDLString);
-}
-
-
-
-#endif // nsXPIDLString_h__

mozilla/xpcom/Makefile.in

@@ -1,41 +0,0 @@
-#!gmake
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-DEPTH	= ..
-topsrcdir	= @top_srcdir@
-VPATH		= @srcdir@
-srcdir		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS=   typelib        \
-        base           \
-        ds             \
-        io             \
-        components     \
-        threads        \
-        reflect        \
-        proxy          \
-        build          \
-        tools          \
-        sample         \
-	$(NULL)
-
-ifdef ENABLE_TESTS
-DIRS += tests
-endif
-
-include $(topsrcdir)/config/rules.mk

mozilla/xpcom/base/MANIFEST

@@ -1,12 +0,0 @@
-nsAgg.h
-nsIAllocator.h
-nsCOMPtr.h
-nsCom.h
-nsDebug.h
-nsError.h
-nsID.h 
-nsIID.h
-nsIPtr.h
-nsISupportsUtils.h
-nsTraceRefcnt.h
-nscore.h

mozilla/xpcom/base/MANIFEST_IDL

@@ -1,2 +0,0 @@
-nsISupports.idl
-nsrootidl.idl

mozilla/xpcom/base/Makefile.in

@@ -1,73 +0,0 @@
-#!gmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-DEPTH=../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-include $(topsrcdir)/config/config.mk
-
-LIBRARY_NAME = xpcombase_s
-
-MODULE = xpcom
-XPIDL_MODULE = xpcom_base
-
-XPIDLSRCS =               \
-	nsrootidl.idl   \
-	nsISupports.idl \
-	$(NULL)
-
-CPPSRCS =				\
-	nsAllocator.cpp			\
-	nsDebug.cpp			\
-	nsTraceRefcnt.cpp		\
-	nsCOMPtr.cpp			\
-	nsID.cpp			\
-	$(NULL)
-
-EXPORTS = \
-        nsAgg.h            \
-        nsIAllocator.h     \
-        nsCOMPtr.h         \
-        nsCom.h            \
-        nsDebug.h          \
-        nsError.h          \
-        nsID.h             \
-	nsIID.h            \
-	nsIPtr.h           \
-        nsISupportsUtils.h \
-        nsTraceRefcnt.h    \
-        nscore.h           \
-	$(NULL)
-
-EXPORTS := $(addprefix $(srcdir)/, $(EXPORTS))
-
-DEFINES += -D_IMPL_NS_COM
-
-REQUIRES = xpcom
-
-MKSHLIB :=
-
-# we don't want the shared lib, but we want to force the creation of a static lib.
-override NO_SHARED_LIB=1
-override NO_STATIC_LIB=
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/xpcom/base/makefile.win

@@ -1,81 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-IGNORE_MANIFEST=1
-
-DEPTH=..\..
-MODULE = xpcom 
-
-################################################################################
-## exports
-
-EXPORTS =                  \
-        nsAgg.h            \
-        nsIAllocator.h     \
-        nsCOMPtr.h         \
-        nsCom.h            \
-        nsDebug.h          \
-        nsError.h          \
-        nsID.h             \
-	nsIID.h            \
-	nsIPtr.h           \
-        nsISupportsUtils.h \
-        nsTraceRefcnt.h    \
-        nscore.h           \
-        $(NULL)			
-
-XPIDL_MODULE = xpcom_base
-
-XPIDLSRCS =               \
-        .\nsrootidl.idl   \
-        .\nsISupports.idl \
-        $(NULL)
-
-################################################################################
-## library
-
-#MAKE_OBJ_TYPE	= DLL
-#LIBNAME = .\$(OBJDIR)\xpcombase
-#DLL = $(LIBNAME).dll
-
-LIBRARY_NAME=xpcombase_s
-
-LINCS =                   \
-	-I$(PUBLIC)\xpcom \
-	$(NULL)
-
-LCFLAGS = -D_IMPL_NS_COM -DWIN32_LEAN_AND_MEAN
-
-CPP_OBJS =                            \
-        .\$(OBJDIR)\nsDebug.obj       \
-        .\$(OBJDIR)\nsAllocator.obj   \
-        .\$(OBJDIR)\nsCOMPtr.obj      \
-        .\$(OBJDIR)\nsID.obj          \
-        .\$(OBJDIR)\nsTraceRefcnt.obj \
-        $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-#libs:: $(DLL)
-#	$(MAKE_INSTALL) $(LIBNAME).$(DLL_SUFFIX) $(DIST)\bin
-#	$(MAKE_INSTALL) $(LIBNAME).$(LIB_SUFFIX) $(DIST)\lib
-
-libs:: $(LIBRARY)
-	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-clobber::
-        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib

mozilla/xpcom/base/nsAgg.h

@@ -1,170 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsAgg_h___
-#define nsAgg_h___
-
-#include "nsISupports.h"
-
-/**
- * Outer objects can implement nsIOuter if they choose, allowing them to 
- * get notification if their inner objects (children) are effectively freed.
- * This allows them to reset any state associated with the inner object and
- * potentially unload it.
- */
-class nsIOuter : public nsISupports {
-public:
-
-    /**
-     * This method is called whenever an inner object's refcount is about to
-     * become zero and the inner object should be released by the outer. This
-     * allows the outer to clean up any state associated with the inner and 
-     * potentially unload the inner object. This method should call 
-     * inner->Release().
-     */
-    NS_IMETHOD
-    ReleaseInner(nsISupports* inner) = 0;
-
-};
-
-#define NS_IOUTER_IID                                \
-{ /* ea0bf9f0-3d67-11d2-8163-006008119d7a */         \
-    0xea0bf9f0,                                      \
-    0x3d67,                                          \
-    0x11d2,                                          \
-    {0x81, 0x63, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a} \
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Put this in your class's declaration:
-#define NS_DECL_AGGREGATED                                                  \
-    NS_DECL_ISUPPORTS                                                       \
-                                                                            \
-protected:                                                                  \
-                                                                            \
-    /* You must implement this operation instead of the nsISupports */      \
-    /* methods if you inherit from nsAggregated. */                         \
-    NS_IMETHOD                                                              \
-    AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr);       \
-                                                                            \
-    class Internal : public nsISupports {                                   \
-    public:                                                                 \
-                                                                            \
-        Internal() {}                                                       \
-                                                                            \
-        NS_IMETHOD QueryInterface(const nsIID& aIID,                        \
-                                        void** aInstancePtr);               \
-        NS_IMETHOD_(nsrefcnt) AddRef(void);                                 \
-        NS_IMETHOD_(nsrefcnt) Release(void);                                \
-                                                                            \
-    };                                                                      \
-                                                                            \
-    friend class Internal;                                                  \
-                                                                            \
-    nsISupports*        fOuter;                                             \
-    Internal            fAggregated;                                        \
-                                                                            \
-    nsISupports* GetInner(void) { return &fAggregated; }                    \
-                                                                            \
-public:                                                                     \
-
-
-// Put this in your class's constructor:
-#define NS_INIT_AGGREGATED(outer)                                           \
-  PR_BEGIN_MACRO                                                            \
-    NS_INIT_REFCNT();                                                       \
-    fOuter = outer;                                                         \
-  PR_END_MACRO
-
-
-// Put this in your class's implementation file:
-#define NS_IMPL_AGGREGATED(_class)                                          \
-NS_IMETHODIMP                                                               \
-_class::QueryInterface(const nsIID& aIID, void** aInstancePtr)              \
-{                                                                           \
-    /* try our own interfaces first before delegating to outer */           \
-    nsresult rslt = AggregatedQueryInterface(aIID, aInstancePtr);           \
-    if (rslt != NS_OK && fOuter)                                            \
-        return fOuter->QueryInterface(aIID, aInstancePtr);                  \
-    else                                                                    \
-        return rslt;                                                        \
-}                                                                           \
-                                                                            \
-NS_IMETHODIMP_(nsrefcnt)                                                    \
-_class::AddRef(void)                                                        \
-{                                                                           \
-    ++mRefCnt; /* keep track of our refcount as well as outer's */          \
-    if (fOuter)                                                             \
-        return NS_ADDREF(fOuter);                                           \
-    else                                                                    \
-        return mRefCnt;                                                     \
-}                                                                           \
-                                                                            \
-NS_IMETHODIMP_(nsrefcnt)                                                    \
-_class::Release(void)                                                       \
-{                                                                           \
-    if (fOuter) {                                                           \
-        nsISupports* outer = fOuter;    /* in case we release ourself */    \
-        nsIOuter* outerIntf;                                                \
-        static NS_DEFINE_IID(kIOuterIID, NS_IOUTER_IID);                    \
-        if (mRefCnt == 1 &&                                                 \
-            outer->QueryInterface(kIOuterIID,                               \
-                                  (void**)&outerIntf) == NS_OK) {           \
-            outerIntf->ReleaseInner(GetInner());                            \
-            outerIntf->Release();                                           \
-        }                                                                   \
-        else                                                                \
-            --mRefCnt; /* keep track of our refcount as well as outer's */  \
-        return outer->Release();                                            \
-    }                                                                       \
-    else {                                                                  \
-        if (--mRefCnt == 0) {                                               \
-            delete this;                                                    \
-            return 0;                                                       \
-        }                                                                   \
-        return mRefCnt;                                                     \
-    }                                                                       \
-}                                                                           \
-                                                                            \
-NS_IMETHODIMP                                                               \
-_class::Internal::QueryInterface(const nsIID& aIID, void** aInstancePtr)    \
-{                                                                           \
-    _class* agg = (_class*)((char*)(this) - offsetof(_class, fAggregated)); \
-    return agg->AggregatedQueryInterface(aIID, aInstancePtr);               \
-}                                                                           \
-                                                                            \
-NS_IMETHODIMP_(nsrefcnt)                                                    \
-_class::Internal::AddRef(void)                                              \
-{                                                                           \
-    _class* agg = (_class*)((char*)(this) - offsetof(_class, fAggregated)); \
-    return ++agg->mRefCnt;                                                  \
-}                                                                           \
-                                                                            \
-NS_IMETHODIMP_(nsrefcnt)                                                    \
-_class::Internal::Release(void)                                             \
-{                                                                           \
-    _class* agg = (_class*)((char*)(this) - offsetof(_class, fAggregated)); \
-    if (--agg->mRefCnt == 0) {                                              \
-        delete agg;                                                         \
-        return 0;                                                           \
-    }                                                                       \
-    return agg->mRefCnt;                                                    \
-}                                                                           \
-
-#endif /* nsAgg_h___ */

mozilla/xpcom/base/nsAllocator.cpp

@@ -1,179 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-////////////////////////////////////////////////////////////////////////////////
-// Implementation of nsIAllocator using NSPR
-////////////////////////////////////////////////////////////////////////////////
-
-#include "nsAllocator.h"
-#include "nsIServiceManager.h"
-#include <string.h>     /* for memcpy */
-
-nsAllocatorImpl::nsAllocatorImpl(nsISupports* outer)
-{
-    NS_INIT_AGGREGATED(outer);
-}
-
-nsAllocatorImpl::~nsAllocatorImpl(void)
-{
-}
-
-NS_IMPL_AGGREGATED(nsAllocatorImpl);
-
-NS_METHOD
-nsAllocatorImpl::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr) 
-{
-    if (NULL == aInstancePtr) {                                            
-        return NS_ERROR_NULL_POINTER;                                        
-    }                                                                      
-    if (aIID.Equals(nsIAllocator::GetIID()) || 
-        aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
-        *aInstancePtr = (void*) this; 
-        AddRef(); 
-        return NS_OK; 
-    } 
-    return NS_NOINTERFACE;
-}
-
-NS_METHOD
-nsAllocatorImpl::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
-{
-    if (outer && !aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID()))
-        return NS_NOINTERFACE;   // XXX right error?
-    nsAllocatorImpl* mm = new nsAllocatorImpl(outer);
-    if (mm == NULL)
-        return NS_ERROR_OUT_OF_MEMORY;
-    mm->AddRef();
-    if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID()))
-        *aInstancePtr = mm->GetInner();
-    else
-        *aInstancePtr = mm;
-    return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-NS_METHOD_(void*)
-nsAllocatorImpl::Alloc(PRUint32 size)
-{
-    return PR_Malloc(size);
-}
-
-NS_METHOD_(void*)
-nsAllocatorImpl::Realloc(void* ptr, PRUint32 size)
-{
-    return PR_Realloc(ptr, size);
-}
-
-NS_METHOD
-nsAllocatorImpl::Free(void* ptr)
-{
-    PR_Free(ptr);
-    return NS_OK;
-}
-
-NS_METHOD
-nsAllocatorImpl::HeapMinimize(void)
-{
-#ifdef XP_MAC
-    // This used to live in the memory allocators no Mac, but does no more
-    // Needs to be hooked up in the new world.
-//    CallCacheFlushers(0x7fffffff);
-#endif
-    return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-#if 0
-nsAllocatorFactory::nsAllocatorFactory(void)
-{
-    NS_INIT_REFCNT();
-}
-
-nsAllocatorFactory::~nsAllocatorFactory(void)
-{
-}
-
-static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
-NS_IMPL_ISUPPORTS(nsAllocatorFactory, kIFactoryIID);
-
-NS_METHOD
-nsAllocatorFactory::CreateInstance(nsISupports *aOuter,
-                                   REFNSIID aIID,
-                                   void **aResult)
-{
-    return nsAllocatorImpl::Create(aOuter, aIID, aResult);
-}
-
-NS_METHOD
-nsAllocatorFactory::LockFactory(PRBool aLock)
-{
-    return NS_OK;       // XXX what?
-}
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-/*
-* Public shortcuts to the shared allocator's methods
-*   (all these methods are class statics)
-*/
-
-// public:
-void* nsAllocator::Alloc(PRUint32 size) 
-{
-    if(!EnsureAllocator()) return NULL;
-    return mAllocator->Alloc(size);
-}
-
-void* nsAllocator::Realloc(void* ptr, PRUint32 size)
-{
-    if(!EnsureAllocator()) return NULL;
-    return mAllocator->Realloc(ptr, size);
-}
-
-void  nsAllocator::Free(void* ptr)
-{
-    if(!EnsureAllocator()) return;
-    mAllocator->Free(ptr);
-}
-
-void  nsAllocator::HeapMinimize()
-{
-    if(!EnsureAllocator()) return;
-    mAllocator->HeapMinimize();
-}
-
-void* nsAllocator::Clone(const void* ptr,  PRUint32 size)
-{
-    if(!ptr || !EnsureAllocator()) return NULL;
-    void* p = mAllocator->Alloc(size);
-    if(p) memcpy(p, ptr, size);
-    return p;
-}        
-
-// private:
-
-nsIAllocator* nsAllocator::mAllocator = NULL;
-
-PRBool nsAllocator::FetchAllocator()
-{
-    nsAllocatorImpl::Create(NULL, nsIAllocator::GetIID(), (void**)&mAllocator);
-    NS_ASSERTION(mAllocator, "failed to get Allocator!");
-    return (PRBool) mAllocator;
-}    

mozilla/xpcom/base/nsAllocator.h

@@ -1,92 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-////////////////////////////////////////////////////////////////////////////////
-// Implementation of nsIAllocator using NSPR
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef nsAllocator_h__
-#define nsAllocator_h__
-
-#include "nsIAllocator.h"
-#include "prmem.h"
-#include "nsAgg.h"
-#include "nsIFactory.h"
-
-class nsAllocatorImpl : public nsIAllocator {
-public:
-    static const nsCID& CID() { static nsCID cid = NS_ALLOCATOR_CID; return cid; }
-
-    /**
-     * Allocates a block of memory of a particular size. 
-     *
-     * @param size - the size of the block to allocate
-     * @result the block of memory
-     */
-    NS_IMETHOD_(void*) Alloc(PRUint32 size);
-
-    /**
-     * Reallocates a block of memory to a new size.
-     *
-     * @param ptr - the block of memory to reallocate
-     * @param size - the new size
-     * @result the rellocated block of memory
-     */
-    NS_IMETHOD_(void*) Realloc(void* ptr, PRUint32 size);
-
-    /**
-     * Frees a block of memory. 
-     *
-     * @param ptr - the block of memory to free
-     */
-    NS_IMETHOD Free(void* ptr);
-
-    /**
-     * Attempts to shrink the heap.
-     */
-    NS_IMETHOD HeapMinimize(void);
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    nsAllocatorImpl(nsISupports* outer);
-    virtual ~nsAllocatorImpl(void);
-
-    NS_DECL_AGGREGATED
-
-    static NS_METHOD
-    Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-#if 0
-class nsAllocatorFactory : public nsIFactory {
-public:
-    NS_IMETHOD CreateInstance(nsISupports *aOuter,
-                              REFNSIID aIID,
-                              void **aResult);
-
-    NS_IMETHOD LockFactory(PRBool aLock);
-
-    nsAllocatorFactory(void);
-    virtual ~nsAllocatorFactory(void);
-
-    NS_DECL_ISUPPORTS
-};
-#endif
-////////////////////////////////////////////////////////////////////////////////
-#endif // nsAllocator_h__

mozilla/xpcom/base/nsCOMPtr.cpp

@@ -1,65 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsCOMPtr.h"
-
-#ifdef NSCAP_FEATURE_FACTOR_DESTRUCTOR
-nsCOMPtr_base::~nsCOMPtr_base()
-	{
-		if ( mRawPtr )
-			NSCAP_RELEASE(mRawPtr);
-	}
-#endif
-
-void
-nsCOMPtr_base::assign_with_AddRef( nsISupports* rawPtr )
-	{
-    if ( rawPtr )
-    	NSCAP_ADDREF(rawPtr);
-    if ( mRawPtr )
-      NSCAP_RELEASE(mRawPtr);
-    mRawPtr = rawPtr;
-	}
-
-void
-nsCOMPtr_base::assign_with_QueryInterface( nsISupports* rawPtr, const nsIID& iid, nsresult* result )
-  {
-    nsresult status = NS_ERROR_NULL_POINTER;
-    if ( !rawPtr || !NS_SUCCEEDED( status = rawPtr->QueryInterface(iid, NSCAP_REINTERPRET_CAST(void**, &rawPtr)) ) )
-      rawPtr = 0;
-
-    if ( mRawPtr )
-      NSCAP_RELEASE(mRawPtr);
-
-    mRawPtr = rawPtr;
-
-    if ( result )
-      *result = status;
-  }
-
-void**
-nsCOMPtr_base::begin_assignment()
-  {
-    if ( mRawPtr )
-    	{
-	      NSCAP_RELEASE(mRawPtr);
-	    	mRawPtr = 0;
-    	}
-
-    return NSCAP_REINTERPRET_CAST(void**, &mRawPtr);
-  }

mozilla/xpcom/base/nsCOMPtr.h

@@ -1,732 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsCOMPtr_h___
-#define nsCOMPtr_h___
-
-
-
-  // Wrapping includes can speed up compiles (see "Large Scale C++ Software Design")
-#ifndef nsDebug_h___
-#include "nsDebug.h"
-  // for |NS_PRECONDITION|
-#endif
-
-#ifndef nsISupports_h___
-#include "nsISupports.h"
-  // for |nsresult|, |NS_ADDREF|, et al
-#endif
-
-/*
-  Public things defined in this file:
-
-                                                        T* rawTptr;
-    class nsCOMPtr<T>                                   nsCOMPtr<T> smartTptr;
-
-    null_nsCOMPtr()                                     smartTptr = null_nsCOMPtr();
-
-    do_QueryInterface( nsISupports* )                   smartTptr = do_QueryInterface(other_ptr);
-    do_QueryInterface( nsISupports*, nsresult* )        smartTptr = do_QueryInterface(other_ptr, &status);
-
-    dont_QueryInterface( T* )                           smartTptr = dont_QueryInterface(rawTptr);
-
-    getter_AddRefs( nsCOMPtr<T>& )
-    getter_AddRefs( T* )
-    dont_AddRef( T* )
-
-    CallQueryInterface( nsISupports*, T** )
-    CallQueryInterface( nsISupports*, nsCOMPtr<T>* )
-*/
-
-/*
-  Having problems?
-  
-  See the User Manual at:
-    <http://www.meer.net/ScottCollins/doc/nsCOMPtr.html>, or
-    <http://www.mozilla.org/projects/xpcom/nsCOMPtr.html>
-*/
-
-
-
-
-/*
-  TO DO...
-  
-    + Improve internal documentation
-      + mention *&
-      + alternatives for comparison
-      + do_QueryInterface
-*/
-
-/*
-  WARNING:
-    This file defines several macros for internal use only.  These macros begin with the
-    prefix |NSCAP_|.  Do not use these macros in your own code.  They are for internal use
-    only for cross-platform compatibility, and are subject to change without notice.
-*/
-
-
-  /*
-    Set up some |#define|s to turn off a couple of troublesome C++ features.
-    Interestingly, none of the compilers barf on template stuff.  These are set up automatically
-    by the autoconf system for all Unixes.  (Temporarily, I hope) I have to define them
-    myself for Mac and Windows.
-  */
-
-  // under Metrowerks (Mac), we don't have autoconf yet
-#ifdef __MWERKS__
-  #define HAVE_CPP_USING
-  #define HAVE_CPP_EXPLICIT
-  #define HAVE_CPP_NEW_CASTS
-  #define HAVE_CPP_BOOL
-#endif
-
-  // under VC++ (Windows), we don't have autoconf yet
-#ifdef _MSC_VER
-  #define HAVE_CPP_EXPLICIT
-  #define HAVE_CPP_USING
-  #define HAVE_CPP_NEW_CASTS
-
-  #if (_MSC_VER<1100)
-      // before 5.0, VC++ couldn't handle explicit
-    #undef HAVE_CPP_EXPLICIT
-  #elif (_MSC_VER==1100)
-      // VC++5.0 has an internal compiler error (sometimes) without this
-    #undef HAVE_CPP_USING
-  #endif
-
-  #define NSCAP_FEATURE_INLINE_STARTASSIGNMENT
-    // under VC++, we win by inlining StartAssignment
-#endif
-
-#define NSCAP_FEATURE_ALLOW_RAW_POINTERS
-#define NSCAP_FEATURE_ALLOW_COMPARISONS
-#define NSCAP_FEATURE_FACTOR_DESTRUCTOR
-
-#ifdef NS_DEBUG
-	#define NSCAP_FEATURE_TEST_DONTQUERY_CASES
-#endif
-
-
-  /*
-    If the compiler doesn't support |explicit|, we'll just make it go away, trusting
-    that the builds under compilers that do have it will keep us on the straight and narrow.
-  */
-#ifndef HAVE_CPP_EXPLICIT
-  #define explicit
-#endif
-
-#ifdef HAVE_CPP_BOOL
-  typedef bool NSCAP_BOOL;
-#else
-  typedef PRBool NSCAP_BOOL;
-#endif
-
-#ifdef HAVE_CPP_NEW_CASTS
-  #define NSCAP_STATIC_CAST(T,x)       static_cast<T>(x)
-  #define NSCAP_REINTERPRET_CAST(T,x)  reinterpret_cast<T>(x)
-#else
-  #define NSCAP_STATIC_CAST(T,x) ((T)(x))
-  #define NSCAP_REINTERPRET_CAST(T,x) ((T)(x))
-#endif
-
-#ifdef NSCAP_FEATURE_DEBUG_MACROS
-  #define NSCAP_ADDREF(ptr)    NS_ADDREF(ptr)
-  #define NSCAP_RELEASE(ptr)   NS_RELEASE(ptr)
-#else
-  #define NSCAP_ADDREF(ptr)    (ptr)->AddRef()
-  #define NSCAP_RELEASE(ptr)   (ptr)->Release()
-#endif
-
-  /*
-    WARNING:
-      VC++4.2 is very picky.  To compile under VC++4.2, the classes must be defined
-      in an order that satisfies:
-    
-        nsDerivedSafe < nsCOMPtr
-        nsDontAddRef < nsCOMPtr
-        nsCOMPtr < nsGetterAddRefs
-
-      The other compilers probably won't complain, so please don't reorder these
-      classes, on pain of breaking 4.2 compatibility.
-  */
-
-
-template <class T>
-class nsDerivedSafe : public T
-    /*
-      No client should ever see or have to type the name of this class.  It is the
-      artifact that makes it a compile-time error to call |AddRef| and |Release|
-      on a |nsCOMPtr|.  DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.
-
-      See |nsCOMPtr::operator->|, |nsCOMPtr::operator*|, et al.
-    */
-  {
-    private:
-#ifdef HAVE_CPP_USING
-      using T::AddRef;
-      using T::Release;
-#else
-      NS_IMETHOD_(nsrefcnt) AddRef(void);
-      NS_IMETHOD_(nsrefcnt) Release(void);
-#endif
-
-      void operator delete( void*, size_t );                  // NOT TO BE IMPLEMENTED
-        // declaring |operator delete| private makes calling delete on an interface pointer a compile error
-
-      nsDerivedSafe<T>& operator=( const nsDerivedSafe<T>& );                // NOT TO BE IMPLEMENTED
-        // you may not call |operator=()| through a dereferenced |nsCOMPtr|, because you'd get the wrong one
-  };
-
-#if !defined(HAVE_CPP_USING) && defined(NEED_CPP_UNUSED_IMPLEMENTATIONS)
-template <class T>
-nsrefcnt
-nsDerivedSafe<T>::AddRef()
-  {
-    return 0;
-  }
-
-template <class T>
-nsrefcnt
-nsDerivedSafe<T>::Release()
-  {
-    return 0;
-  }
-
-#endif
-
-
-
-
-template <class T>
-struct nsDontQueryInterface
-    /*
-      ...
-
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |dont_QueryInterface()| instead.
-    */
-  {
-    explicit
-    nsDontQueryInterface( T* aRawPtr )
-        : mRawPtr(aRawPtr)
-      {
-        // nothing else to do here
-      }
-
-    T* mRawPtr;
-  };
-
-template <class T>
-inline
-const nsDontQueryInterface<T>
-dont_QueryInterface( T* aRawPtr )
-  {
-    return nsDontQueryInterface<T>(aRawPtr);
-  }
-
-
-
-
-struct nsQueryInterface
-    /*
-      ...
-
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |do_QueryInterface()| instead.
-    */
-  {
-    explicit
-    nsQueryInterface( nsISupports* aRawPtr, nsresult* error = 0 )
-        : mRawPtr(aRawPtr),
-          mErrorPtr(error)
-      {
-        // nothing else to do here
-      }
-
-    nsISupports* mRawPtr;
-    nsresult*    mErrorPtr;
-  };
-
-inline
-const nsQueryInterface
-do_QueryInterface( nsISupports* aRawPtr, nsresult* error = 0 )
-  {
-    return nsQueryInterface(aRawPtr, error);
-  }
-
-#ifdef NSCAP_FEATURE_ALLOW_RAW_POINTERS
-
-  #define null_nsCOMPtr() (0)
-
-#else
-
-  inline
-  const nsQueryInterface
-  null_nsCOMPtr()
-      /*
-        You can use this to assign |NULL| into an |nsCOMPtr|, e.g.,
-
-          myPtr = null_nsCOMPtr();
-      */
-    {
-      typedef nsISupports* nsISupports_Ptr;
-      return nsQueryInterface(nsISupports_Ptr(0));
-    }
-
-#endif
-
-
-
-template <class T>
-struct nsDontAddRef
-    /*
-      ...cooperates with |nsCOMPtr| to allow you to assign in a pointer _without_
-      |AddRef|ing it.  You would rarely use this directly, but rather through the
-      machinery of |getter_AddRefs| in the argument list to functions that |AddRef|
-      their results before returning them to the caller.
-
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| or
-      |dont_AddRef()| instead.
-
-      See also |getter_AddRefs()|, |dont_AddRef()|, and |class nsGetterAddRefs|.
-    */
-  {
-    explicit
-    nsDontAddRef( T* aRawPtr )
-        : mRawPtr(aRawPtr)
-      {
-        // nothing else to do here
-      }
-
-    T* mRawPtr;
-  };
-
-template <class T>
-inline
-const nsDontAddRef<T>
-getter_AddRefs( T* aRawPtr )
-    /*
-      ...makes typing easier, because it deduces the template type, e.g., 
-      you write |dont_AddRef(fooP)| instead of |nsDontAddRef<IFoo>(fooP)|.
-    */
-  {
-    return nsDontAddRef<T>(aRawPtr);
-  }
-
-template <class T>
-inline
-const nsDontAddRef<T>
-dont_AddRef( T* aRawPtr )
-  {
-    return nsDontAddRef<T>(aRawPtr);
-  }
-
-
-
-class nsCOMPtr_base
-    /*
-      ...factors implementation for all template versions of |nsCOMPtr|.
-    */
-  {
-    public:
-
-      nsCOMPtr_base( nsISupports* rawPtr = 0 )
-          : mRawPtr(rawPtr)
-        {
-          // nothing else to do here
-        }
-
-#ifdef NSCAP_FEATURE_FACTOR_DESTRUCTOR
-     NS_EXPORT ~nsCOMPtr_base();
-#endif
-
-#if 0
-     ~nsCOMPtr_base()
-        {
-          if ( mRawPtr )
-            NSCAP_RELEASE(mRawPtr);
-        }
-#endif
-
-      NS_EXPORT void    assign_with_AddRef( nsISupports* );
-      NS_EXPORT void    assign_with_QueryInterface( nsISupports*, const nsIID&, nsresult* );
-      NS_EXPORT void**  begin_assignment();
-
-    protected:
-      nsISupports* mRawPtr;
-  };
-
-
-
-template <class T>
-class nsCOMPtr : private nsCOMPtr_base
-    /*
-      ...
-    */
-  {
-    public:
-      typedef T element_type;
-      
-#if 0
-			typedef nsDerivedSafe<T>* safe_ptr_t;
-			typedef T* safe_ptr_t;
-#endif
-
-#ifndef NSCAP_FEATURE_FACTOR_DESTRUCTOR
-     ~nsCOMPtr()
-        {
-          if ( mRawPtr )
-            NSCAP_RELEASE(mRawPtr);
-        }
-#endif
-
-      nsCOMPtr()
-          // : nsCOMPtr_base(0)
-        {
-          // nothing else to do here
-        }
-
-      nsCOMPtr( const nsQueryInterface& aSmartPtr )
-          // : nsCOMPtr_base(0)
-        {
-          assign_with_QueryInterface(aSmartPtr.mRawPtr, nsCOMTypeInfo<T>::GetIID(), aSmartPtr.mErrorPtr);
-        }
-
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-			void
-			Assert_NoQueryNeeded()
-				{
-          if ( !mRawPtr )
-            return;
-					T* query_result = 0;
-					nsresult status = CallQueryInterface(mRawPtr, &query_result);
-					NS_ASSERTION(query_result == mRawPtr, "QueryInterface needed");
-					if ( NS_SUCCEEDED(status) )
-						NSCAP_RELEASE(query_result);
-				}
-#endif
-
-      nsCOMPtr( const nsDontAddRef<T>& aSmartPtr )
-          : nsCOMPtr_base(aSmartPtr.mRawPtr)
-        {
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-					Assert_NoQueryNeeded();
-#endif
-        }
-
-      nsCOMPtr( const nsDontQueryInterface<T>& aSmartPtr )
-          : nsCOMPtr_base(aSmartPtr.mRawPtr)
-        {
-          if ( mRawPtr )
-            NSCAP_ADDREF(mRawPtr);
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-					Assert_NoQueryNeeded();
-#endif
-        }
-
-      nsCOMPtr( const nsCOMPtr<T>& aSmartPtr )
-          : nsCOMPtr_base(aSmartPtr.mRawPtr)
-        {
-          if ( mRawPtr )
-            NSCAP_ADDREF(mRawPtr);
-        }
-
-#ifdef NSCAP_FEATURE_ALLOW_RAW_POINTERS
-      nsCOMPtr( T* aRawPtr )
-          : nsCOMPtr_base(aRawPtr)
-        {
-          if ( mRawPtr )
-            NSCAP_ADDREF(mRawPtr);
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-					Assert_NoQueryNeeded();
-#endif
-        }
-
-      nsCOMPtr<T>&
-      operator=( T* rhs )
-        {
-          assign_with_AddRef(rhs);
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-					Assert_NoQueryNeeded();
-#endif
-          return *this;
-        }
-#endif
-
-      nsCOMPtr<T>&
-      operator=( const nsQueryInterface& rhs )
-        {
-          assign_with_QueryInterface(rhs.mRawPtr, nsCOMTypeInfo<T>::GetIID(), rhs.mErrorPtr);
-          return *this;
-        }
-
-      nsCOMPtr<T>&
-      operator=( const nsDontAddRef<T>& rhs )
-        {
-          if ( mRawPtr )
-            NSCAP_RELEASE(mRawPtr);
-          mRawPtr = rhs.mRawPtr;
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-					Assert_NoQueryNeeded();
-#endif
-          return *this;
-        }
-
-      nsCOMPtr<T>&
-      operator=( const nsDontQueryInterface<T>& rhs )
-        {
-          assign_with_AddRef(rhs.mRawPtr);
-#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
-					Assert_NoQueryNeeded();
-#endif
-          return *this;
-        }
-
-      nsCOMPtr<T>&
-      operator=( const nsCOMPtr<T>& rhs )
-        {
-          assign_with_AddRef(rhs.mRawPtr);
-          return *this;
-        }
-
-      nsDerivedSafe<T>*
-      get() const
-          // returns a |nsDerivedSafe<T>*| to deny clients the use of |AddRef| and |Release|
-        {
-          return NSCAP_REINTERPRET_CAST(nsDerivedSafe<T>*, mRawPtr);
-        }
-
-      nsDerivedSafe<T>*
-      operator->() const
-          // returns a |nsDerivedSafe<T>*| to deny clients the use of |AddRef| and |Release|
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator->().");
-          return get();
-        }
-
-      nsDerivedSafe<T>&
-      operator*() const
-          // returns a |nsDerivedSafe<T>*| to deny clients the use of |AddRef| and |Release|
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator*().");
-          return *get();
-        }
-
-      operator nsDerivedSafe<T>*() const
-        {
-          return get();
-        }
-
-#if 0
-    private:
-      friend class nsGetterAddRefs<T>;
-
-      /*
-        In a perfect world, the following member function, |StartAssignment|, would be private.
-        It is and should be only accessed by the closely related class |nsGetterAddRefs<T>|.
-
-        Unfortunately, some compilers---most notably VC++5.0---fail to grok the
-        friend declaration above or in any alternate acceptable form.  So, physically
-        it will be public (until our compilers get smarter); but it is not to be
-        considered part of the logical public interface.
-      */
-#endif
-
-      T**
-      StartAssignment()
-        {
-#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
-          return NSCAP_REINTERPRET_CAST(T**, begin_assignment());
-#else
-          if ( mRawPtr )
-            NSCAP_RELEASE(mRawPtr);
-          mRawPtr = 0;
-          return NSCAP_REINTERPRET_CAST(T**, &mRawPtr);
-#endif
-        }
-  };
-
-
-template <class T>
-class nsGetterAddRefs
-    /*
-      ...
-
-      This class is designed to be used for anonymous temporary objects in the
-      argument list of calls that return COM interface pointers, e.g.,
-
-        nsCOMPtr<IFoo> fooP;
-        ...->QueryInterface(iid, getter_AddRefs(fooP))
-
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
-
-      When initialized with a |nsCOMPtr|, as in the example above, it returns
-      a |void**| (or |T**| if needed) that the outer call (|QueryInterface| in this
-      case) can fill in.
-    */
-  {
-    public:
-      explicit
-      nsGetterAddRefs( nsCOMPtr<T>& aSmartPtr )
-          : mTargetSmartPtr(aSmartPtr)
-        {
-          // nothing else to do
-        }
-
-      operator void**()
-        {
-          return NSCAP_REINTERPRET_CAST(void**, mTargetSmartPtr.StartAssignment());
-        }
-
-      T*&
-      operator*()
-        {
-          return *(mTargetSmartPtr.StartAssignment());
-        }
-
-      operator T**()
-        {
-          return mTargetSmartPtr.StartAssignment();
-        }
-
-    private:
-      nsCOMPtr<T>& mTargetSmartPtr;
-  };
-
-template <class T>
-inline
-nsGetterAddRefs<T>
-getter_AddRefs( nsCOMPtr<T>& aSmartPtr )
-    /*
-      Used around a |nsCOMPtr| when 
-      ...makes the class |nsGetterAddRefs<T>| invisible.
-    */
-  {
-    return nsGetterAddRefs<T>(aSmartPtr);
-  }
-
-
-#ifdef NSCAP_FEATURE_ALLOW_COMPARISONS
-
-class NSCAP_Zero;
-
-template <class T, class U>
-inline
-NSCAP_BOOL
-operator==( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs.get()) == NSCAP_STATIC_CAST(const void*, rhs.get());
-  }
-
-template <class T, class U>
-inline
-NSCAP_BOOL
-operator==( const nsCOMPtr<T>& lhs, const U* rhs )
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs.get()) == NSCAP_STATIC_CAST(const void*, rhs);
-  }
-
-template <class T, class U>
-inline
-NSCAP_BOOL
-operator==( const U* lhs, const nsCOMPtr<T>& rhs )
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs) == NSCAP_STATIC_CAST(const void*, rhs.get());
-  }
-
-template <class T>
-inline
-NSCAP_BOOL
-operator==( const nsCOMPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs.get()) == NSCAP_REINTERPRET_CAST(const void*, rhs);
-  }
-
-template <class T>
-inline
-NSCAP_BOOL
-operator==( NSCAP_Zero* lhs, const nsCOMPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return NSCAP_REINTERPRET_CAST(const void*, lhs) == NSCAP_STATIC_CAST(const void*, rhs.get());
-  }
-
-template <class T, class U>
-inline
-NSCAP_BOOL
-operator!=( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs.get()) != NSCAP_STATIC_CAST(const void*, rhs.get());
-  }
-
-template <class T, class U>
-inline
-NSCAP_BOOL
-operator!=( const nsCOMPtr<T>& lhs, const U* rhs )
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs.get()) != NSCAP_STATIC_CAST(const void*, rhs);
-  }
-
-template <class T, class U>
-inline
-NSCAP_BOOL
-operator!=( const U* lhs, const nsCOMPtr<T>& rhs )
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs) != NSCAP_STATIC_CAST(const void*, rhs.get());
-  }
-
-template <class T>
-inline
-NSCAP_BOOL
-operator!=( const nsCOMPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr != 0|
-  {
-    return NSCAP_STATIC_CAST(const void*, lhs.get()) != NSCAP_REINTERPRET_CAST(const void*, rhs);
-  }
-
-template <class T>
-inline
-NSCAP_BOOL
-operator!=( NSCAP_Zero* lhs, const nsCOMPtr<T>& rhs )
-    // specifically to allow |0 != smartPtr|
-  {
-    return NSCAP_REINTERPRET_CAST(const void*, lhs) != NSCAP_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) );
-  }
-
-#endif // defined(NSCAP_FEATURE_ALLOW_COMPARISONS)
-
-
-template <class DestinationType>
-inline
-nsresult
-CallQueryInterface( nsISupports* aSource, nsCOMPtr<DestinationType>* aDestination )
-    // a type-safe shortcut for calling the |QueryInterface()| member function
-  {
-    return CallQueryInterface(aSource, getter_AddRefs(*aDestination));
-    	// this calls the _other_ |CallQueryInterface|
-  }
-
-
-#endif // !defined(nsCOMPtr_h___)

mozilla/xpcom/base/nsCom.h

@@ -1,229 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsCom_h__
-#define nsCom_h__
-
-/*
- * API Import/Export macros
- */
-
-#ifdef _IMPL_NS_COM
-#ifdef XP_PC
-#define NS_COM _declspec(dllexport)
-#elif defined(XP_MAC)
-#define NS_COM __declspec(export)
-#else  /* !XP_PC */
-#define NS_COM
-#endif /* !XP_PC */
-#else  /* !_IMPL_NS_COM */
-#ifdef XP_PC
-#define NS_COM _declspec(dllimport)
-#else  /* !XP_PC */
-#define NS_COM
-#endif /* !XP_PC */
-#endif /* !_IMPL_NS_COM */
-
-/*
- * DLL Export macro
- */
-
-#if defined(XP_PC)
-
-#define NS_EXPORT _declspec(dllexport)
-#define NS_EXPORT_(type) _declspec(dllexport) type __stdcall
-
-#define NS_IMETHOD_(type) virtual type __stdcall
-#define NS_IMETHOD virtual nsresult __stdcall
-#define NS_IMETHODIMP_(type) type __stdcall
-#define NS_IMETHODIMP nsresult __stdcall
-
-#define NS_METHOD_(type) type __stdcall
-#define NS_METHOD nsresult __stdcall
-
-#define NS_CALLBACK_(_type, _name) _type (__stdcall * _name)
-#define NS_CALLBACK(_name) nsresult (__stdcall * _name)
-
-#elif defined(XP_MAC)
-
-#define NS_EXPORT __declspec(export)
-#define NS_EXPORT_(type) __declspec(export) type
-
-#define NS_IMETHOD_(type) virtual type
-#define NS_IMETHOD virtual nsresult
-#define NS_IMETHODIMP_(type) type
-#define NS_IMETHODIMP nsresult
-
-#define NS_METHOD_(type) type
-#define NS_METHOD nsresult
-
-#define NS_CALLBACK_(_type, _name) _type (* _name)
-#define NS_CALLBACK(_name) nsresult (* _name)
-
-#else  /* !XP_PC && !XP_MAC */
-
-#define NS_EXPORT
-#define NS_EXPORT_(type) type
-
-#define NS_IMETHOD_(type) virtual type
-#define NS_IMETHOD virtual nsresult
-#define NS_IMETHODIMP_(type) type
-#define NS_IMETHODIMP nsresult
-
-#define NS_METHOD_(type) type
-#define NS_METHOD nsresult
-
-#define NS_CALLBACK_(_type, _name) _type (* _name)
-#define NS_CALLBACK(_name) nsresult (* _name)
-
-#endif /* !XP_PC */
-
-/* use these functions to associate get/set methods with a
-   C++ member variable
-*/
-
-#define NS_METHOD_GETTER(_method, _type, _member) \
-_method(_type* aResult) \
-{\
-    if (!aResult) return NS_ERROR_NULL_POINTER; \
-    *aResult = _member; \
-    return NS_OK; \
-}
-    
-#define NS_METHOD_SETTER(_method, _type, _member) \
-_method(_type aResult) \
-{ \
-    _member = aResult; \
-    return NS_OK; \
-}
-
-/*
- * special for strings to get/set char* strings
- * using PL_strdup and PR_FREEIF
- */
-#define NS_METHOD_GETTER_STR(_method,_member) \
-_method(char* *aString)\
-{\
-    if (!aString) return NS_ERROR_NULL_POINTER; \
-    *aString = PL_strdup(_member); \
-    return NS_OK; \
-}
-
-#define NS_METHOD_SETTER_STR(_method, _member) \
-_method(char *aString)\
-{\
-    PR_FREEIF(_member);\
-    if (aString) _member = PL_strdup(aString); \
-    else _member = nsnull;\
-    return NS_OK; \
-}
-
-/* Getter/Setter macros.
-   Usage:
-   NS_IMPL_[CLASS_]GETTER[_<type>](method, [type,] member);
-   NS_IMPL_[CLASS_]SETTER[_<type>](method, [type,] member);
-   NS_IMPL_[CLASS_]GETSET[_<type>]([class, ]postfix, [type,] member);
-   
-   where:
-   CLASS_  - implementation is inside a class definition
-             (otherwise the class name is needed)
-             Do NOT use in publicly exported header files, because
-             the implementation may be included many times over.
-             Instead, use the non-CLASS_ version.
-   _<type> - For more complex (STR, IFACE) data types
-             (otherwise the simple data type is needed)
-   method  - name of the method, such as GetWidth or SetColor
-   type    - simple data type if required
-   member  - class member variable such as m_width or mColor
-   class   - the class name, such as Window or MyObject
-   postfix - Method part after Get/Set such as "Width" for "GetWidth"
-   
-   Example:
-   class Window {
-   public:
-     NS_IMPL_CLASS_GETSET(Width, int, m_width);
-     NS_IMPL_CLASS_GETTER_STR(GetColor, m_color);
-     NS_IMETHOD SetColor(char *color);
-     
-   private:
-     int m_width;     // read/write
-     char *m_color;   // readonly
-   };
-
-   // defined outside of class
-   NS_IMPL_SETTER_STR(Window::GetColor, m_color);
-
-   Questions/Comments to alecf@netscape.com
-*/
-
-   
-/*
- * Getter/Setter implementation within a class definition
- */
-
-/* simple data types */
-#define NS_IMPL_CLASS_GETTER(_method, _type, _member) \
-NS_IMETHOD NS_METHOD_GETTER(_method, _type, _member)
-
-#define NS_IMPL_CLASS_SETTER(_method, _type, _member) \
-NS_IMETHOD NS_METHOD_SETTER(_method, _type, _member)
-
-#define NS_IMPL_CLASS_GETSET(_postfix, _type, _member) \
-NS_IMPL_CLASS_GETTER(Get##_postfix, _type, _member) \
-NS_IMPL_CLASS_SETTER(Set##_postfix, _type, _member)
-
-/* strings */
-#define NS_IMPL_CLASS_GETTER_STR(_method, _member) \
-NS_IMETHOD NS_METHOD_GETTER_STR(_method, _member)
-
-#define NS_IMPL_CLASS_SETTER_STR(_method, _member) \
-NS_IMETHOD NS_METHOD_SETTER_STR(_method, _member)
-
-#define NS_IMPL_CLASS_GETSET_STR(_postfix, _member) \
-NS_IMPL_CLASS_GETTER_STR(Get##_postfix, _member) \
-NS_IMPL_CLASS_SETTER_STR(Set##_postfix, _member)
-
-/* Getter/Setter implementation outside of a class definition */
-
-/* simple data types */
-#define NS_IMPL_GETTER(_method, _type, _member) \
-NS_IMETHODIMP NS_METHOD_GETTER(_method, _type, _member)
-
-#define NS_IMPL_SETTER(_method, _type, _member) \
-NS_IMETHODIMP NS_METHOD_SETTER(_method, _type, _member)
-
-#define NS_IMPL_GETSET(_class, _postfix, _type, _member) \
-NS_IMPL_GETTER(_class::Get##_postfix, _type, _member) \
-NS_IMPL_SETTER(_class::Set##_postfix, _type, _member)
-
-/* strings */
-#define NS_IMPL_GETTER_STR(_method, _member) \
-NS_IMETHODIMP NS_METHOD_GETTER_STR(_method, _member)
-
-#define NS_IMPL_SETTER_STR(_method, _member) \
-NS_IMETHODIMP NS_METHOD_SETTER_STR(_method, _member)
-
-#define NS_IMPL_GETSET_STR(_class, _postfix, _member) \
-NS_IMPL_GETTER_STR(_class::Get##_postfix, _member) \
-NS_IMPL_SETTER_STR(_class::Set##_postfix, _member)
-
-
-
-#endif
-
-

mozilla/xpcom/base/nsDebug.cpp

@@ -1,205 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsDebug.h"
-#include "prlog.h"
-#include "prinit.h"
-
-#if defined(XP_BEOS)
-/* For DEBUGGER macros */
-#include <Debug.h>
-#endif
-
-#if defined(XP_UNIX)
-/* for abort() */
-#include <stdlib.h>
-#endif
-
-#if defined(_WIN32)
-#include <windows.h>
-#elif defined(XP_MAC)
-   #define TEMP_MAC_HACK
-   
-   //------------------------
-   #ifdef TEMP_MAC_HACK
-	   #include <MacTypes.h>
-	   #include <Processes.h>
-	   #include <string.h>
-
-	   // TEMPORARY UNTIL WE HAVE MACINTOSH ENVIRONMENT VARIABLES THAT CAN TURN ON
-	   // LOGGING ON MACINTOSH
-	   // At this moment, NSPR's logging is a no-op on Macintosh.
-
-	   #include <stdarg.h>
-	   #include <stdio.h>
-	 
-	   #undef PR_LOG
-	   #undef PR_LogFlush
-	   #define PR_LOG(module,level,args) dprintf args
-	   #define PR_LogFlush()
-	   static void dprintf(const char *format, ...)
-	   {
-	      va_list ap;
-	      Str255 buffer;
-	      
-	      va_start(ap, format);
-	      buffer[0] = vsnprintf((char *)buffer + 1, sizeof(buffer) - 1, format, ap);
-	      va_end(ap);
-	      if (strstr(format, "Warning: ") == format)
-	 	      printf("¥¥¥%s\n", (char*)buffer + 1);
-	 	  else
-	 	      DebugStr(buffer);
-	   }
-   #endif // TEMP_MAC_HACK
-   //------------------------
-#elif defined(XP_UNIX)
-#include<stdlib.h>
-#endif
-
-
-/**
- * Implementation of the nsDebug methods. Note that this code is
- * always compiled in, in case some other module that uses it is
- * compiled with debugging even if this library is not.
- */
-
-static PRLogModuleInfo* gDebugLog;
-
-static void InitLog(void)
-{
-  if (0 == gDebugLog) {
-    gDebugLog = PR_NewLogModule("nsDebug");
-    gDebugLog->level = PR_LOG_DEBUG;
-  }
-}
-
-NS_COM void nsDebug::Abort(const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("Abort: at file %s, line %d", aFile, aLine));
-  PR_LogFlush();
-#if defined(_WIN32)
-  long* __p = (long*) 0x7;
-  *__p = 0x7;
-#elif defined(XP_MAC)
-  ExitToShell();
-#elif defined(XP_UNIX)
-  PR_Abort();
-#elif defined(XP_BEOS)
-  {
-	char buf[2000];
-	sprintf(buf, "Abort: at file %s, line %d", aFile, aLine);
-	DEBUGGER(buf);
-  } 
-#endif
-}
-
-NS_COM void nsDebug::Break(const char* aFile, PRIntn aLine)
-{
-#ifndef TEMP_MAC_HACK
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("Break: at file %s, line %d", aFile, aLine));
-  PR_LogFlush();
-#if defined(_WIN32)
-  ::DebugBreak();
-#elif defined(XP_UNIX) && !defined(UNIX_CRASH_ON_ASSERT)
-  fprintf(stderr, "\07");  fflush(stderr);
-#elif defined(XP_BEOS)
-  {
-	char buf[2000];
-	sprintf(buf, "Break: at file %s, line %d", aFile, aLine);
-	DEBUGGER(buf);
-  }
-#else
-  Abort(aFile, aLine);
-#endif
-#endif // TEMP_MAC_HACK
-}
-
-NS_COM void nsDebug::PreCondition(const char* aStr, const char* aExpr,
-                                  const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("PreCondition: \"%s\" (%s) at file %s, line %d", aStr, aExpr,
-          aFile, aLine));
-  Break(aFile, aLine);
-}
-
-NS_COM void nsDebug::PostCondition(const char* aStr, const char* aExpr,
-                                   const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("PostCondition: \"%s\" (%s) at file %s, line %d", aStr, aExpr,
-          aFile, aLine));
-  Break(aFile, aLine);
-}
-
-NS_COM void nsDebug::Assertion(const char* aStr, const char* aExpr,
-                               const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("Assertion: \"%s\" (%s) at file %s, line %d", aStr, aExpr,
-          aFile, aLine));
-#if defined(XP_UNIX)
-  fprintf(stderr, "Assertion: \"%s\" (%s) at file %s, line %d\n", aStr, aExpr,
-          aFile, aLine);
-#endif
-  Break(aFile, aLine);
-}
-
-NS_COM void nsDebug::NotYetImplemented(const char* aMessage,
-                                       const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("NotYetImplemented: \"%s\" at file %s, line %d", aMessage,
-          aFile, aLine));
-  Break(aFile, aLine);
-}
-
-NS_COM void nsDebug::NotReached(const char* aMessage,
-                                const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("NotReached: \"%s\" at file %s, line %d", aMessage, aFile, aLine));
-  Break(aFile, aLine);
-}
-
-NS_COM void nsDebug::Error(const char* aMessage,
-                           const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("Error: \"%s\" at file %s, line %d", aMessage, aFile, aLine));
-  Break(aFile, aLine);
-}
-
-NS_COM void nsDebug::Warning(const char* aMessage,
-                             const char* aFile, PRIntn aLine)
-{
-  InitLog();
-  PR_LOG(gDebugLog, PR_LOG_ERROR,
-         ("Warning: \"%s\" at file %s, line %d", aMessage, aFile, aLine));
-  PR_LogFlush();
-}

mozilla/xpcom/base/nsDebug.h

@@ -1,183 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsDebug_h___
-#define nsDebug_h___
-
-#include "nsCom.h"
-#include "prtypes.h"
-
-#ifdef DEBUG
-#define NS_DEBUG
-#endif
-
-/**
- * Namespace for debugging methods. Note that your code must use the
- * macros defined later in this file so that the debug code can be
- * conditionally compiled out.
- */
-
-/* in case this is included by a C file */
-#ifdef __cplusplus
-
-class nsDebug {
-public:
-  // XXX add in log controls here
-  // XXX probably want printf type arguments
-
-  /**
-   * Abort the executing program. This works on all architectures.
-   */
-  static NS_COM void Abort(const char* aFile, PRIntn aLine);
-
-  /**
-   * Break the executing program into the debugger. 
-   */
-  static NS_COM void Break(const char* aFile, PRIntn aLine);
-
-  /**
-   * Log a pre-condition message to the debug log
-   */
-  static NS_COM void PreCondition(const char* aStr, const char* aExpr,
-                                  const char* aFile, PRIntn aLine);
-
-  /**
-   * Log a post-condition message to the debug log
-   */
-  static NS_COM void PostCondition(const char* aStr, const char* aExpr,
-                                   const char* aFile, PRIntn aLine);
-
-  /**
-   * Log an assertion message to the debug log
-   */
-  static NS_COM void Assertion(const char* aStr, const char* aExpr,
-                               const char* aFile, PRIntn aLine);
-
-  /**
-   * Log a not-yet-implemented message to the debug log
-   */
-  static NS_COM void NotYetImplemented(const char* aMessage,
-                                       const char* aFile, PRIntn aLine);
-
-  /**
-   * Log a not-reached message to the debug log
-   */
-  static NS_COM void NotReached(const char* aMessage,
-                                const char* aFile, PRIntn aLine);
-
-  /**
-   * Log an error message to the debug log. This call returns.
-   */
-  static NS_COM void Error(const char* aMessage,
-                           const char* aFile, PRIntn aLine);
-
-  /**
-   * Log a warning message to the debug log.
-   */
-  static NS_COM void Warning(const char* aMessage,
-                             const char* aFile, PRIntn aLine);
-};
-
-#ifdef NS_DEBUG
-/**
- * Test a precondition for truth. If the expression is not true then
- * trigger a program failure.
- */
-#define NS_PRECONDITION(expr,str) \
-if (!(expr))                      \
-  nsDebug::PreCondition(str, #expr, __FILE__, __LINE__)
-
-/**
- * Test an assertion for truth. If the expression is not true then
- * trigger a program failure.
- */
-#define NS_ASSERTION(expr,str) \
-if (!(expr))                   \
-  nsDebug::Assertion(str, #expr, __FILE__, __LINE__)
-
-/**
- * Test an assertion for truth. If the expression is not true then
- * trigger a program failure. The expression will still be
- * executed in release mode.
- */
-#define NS_VERIFY(expr,str) \
-if (!(expr))                \
-  nsDebug::Assertion(str, #expr, __FILE__, __LINE__)
-
-/**
- * Test a post-condition for truth. If the expression is not true then
- * trigger a program failure.
- */
-#define NS_POSTCONDITION(expr,str) \
-if (!(expr))                       \
-  nsDebug::PostCondition(str, #expr, __FILE__, __LINE__)
-
-/**
- * This macros triggers a program failure if executed. It indicates that
- * an attempt was made to execute some unimplimented functionality.
- */
-#define NS_NOTYETIMPLEMENTED(str) \
-  nsDebug::NotYetImplemented(str, __FILE__, __LINE__)
-
-/**
- * This macros triggers a program failure if executed. It indicates that
- * an attempt was made to execute some unimplimented functionality.
- */
-#define NS_NOTREACHED(str) \
-  nsDebug::NotReached(str, __FILE__, __LINE__)
-
-/**
- * Log an error message.
- */
-#define NS_ERROR(str) \
-  nsDebug::Error(str, __FILE__, __LINE__)
-
-/**
- * Log a warning message.
- */
-#define NS_WARNING(str) \
-  nsDebug::Warning(str, __FILE__, __LINE__)
-
-/**
- * Trigger an abort
- */
-#define NS_ABORT() \
-  nsDebug::Abort(__FILE__, __LINE__)
-
-/**
- * Cause a break
- */
-#define NS_BREAK() \
-  nsDebug::Break(__FILE__, __LINE__)
-
-#else /* NS_DEBUG */
-
-#define NS_PRECONDITION(expr,str)  {}
-#define NS_ASSERTION(expr,str)     {}
-#define NS_VERIFY(expr,str)        expr
-#define NS_POSTCONDITION(expr,str) {}
-#define NS_NOTYETIMPLEMENTED(str)  {}
-#define NS_NOTREACHED(str)         {}
-#define NS_ERROR(str)              {}
-#define NS_WARNING(str)            {}
-#define NS_ABORT()                 {}
-#define NS_BREAK()                 {}
-
-#endif /* ! NS_DEBUG */
-#endif /* __cplusplus */
-#endif /* nsDebug_h___ */

mozilla/xpcom/base/nsError.h

@@ -1,189 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsError_h
-#define nsError_h
-
-#ifndef prtypes_h___
-#include "prtypes.h"
-#endif
-
-/**
- * Generic result data type
- */
-
-typedef PRUint32 nsresult;
-
-/*
- * To add error code to your module, you need to do the following:
- *
- * 1) Add a module offset code.  Add yours to the bottom of the list 
- *    right below this comment, adding 1.
- *
- * 2) In your module, define a header file which uses one of the
- *    NE_ERROR_GENERATExxxxxx macros.  Some examples below:
- *
- *    #define NS_ERROR_MYMODULE_MYERROR1 NS_ERROR_GENERATE(NS_ERROR_SEVERITY_ERROR,NS_ERROR_MODULE_MYMODULE,1)
- *    #define NS_ERROR_MYMODULE_MYERROR2 NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_MYMODULE,2)
- *    #define NS_ERROR_MYMODULE_MYERROR3 NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_MYMODULE,3)
- *
- */
-
-
-/**
- * @name Standard Module Offset Code. Each Module should identify a unique number
- *       and then all errors associated with that module become offsets from the
- *       base associated with that module id. There are 16 bits of code bits for
- *       each module.
- */
-
-#define NS_ERROR_MODULE_XPCOM      1
-#define NS_ERROR_MODULE_BASE       2
-#define NS_ERROR_MODULE_GFX        3
-#define NS_ERROR_MODULE_WIDGET     4
-#define NS_ERROR_MODULE_CALENDAR   5
-#define NS_ERROR_MODULE_NETWORK    6
-#define NS_ERROR_MODULE_PLUGINS    7
-#define NS_ERROR_MODULE_LAYOUT     8
-#define NS_ERROR_MODULE_HTMLPARSER 9
-#define NS_ERROR_MODULE_RDF        10
-#define NS_ERROR_MODULE_UCONV      11
-#define NS_ERROR_MODULE_REG        12
-#define NS_ERROR_MODULE_FILES      13
-
-#define NS_ERROR_MODULE_MAILNEWS   16
-#define NS_ERROR_MODULE_EDITOR     17
-
-/**
- * @name Standard Error Handling Macros
- */
-
-#define NS_FAILED(_nsresult) ((_nsresult) & 0x80000000)
-#define NS_SUCCEEDED(_nsresult) (!((_nsresult) & 0x80000000))
-
-/**
- * @name Severity Code.  This flag identifies the level of warning
- */
-
-#define NS_ERROR_SEVERITY_SUCCESS       0
-#define NS_ERROR_SEVERITY_ERROR         1
-
-/**
- * @name Mozilla Code.  This flag separates consumers of mozilla code
- *       from the native platform
- */
-
-#define NS_ERROR_MODULE_BASE_OFFSET 0x45
-
-/**
- * @name Standard Error Generating Macros
- */
-
-#define NS_ERROR_GENERATE(sev,module,code) \
-    ((nsresult) (((PRUint32)(sev)<<31) | ((PRUint32)(module+NS_ERROR_MODULE_BASE_OFFSET)<<16) | ((PRUint32)(code))) )
-
-#define NS_ERROR_GENERATE_SUCCESS(module,code) \
-    ((nsresult) (((PRUint32)(NS_ERROR_SEVERITY_SUCCESS)<<31) | ((PRUint32)(module+NS_ERROR_MODULE_BASE_OFFSET)<<16) | ((PRUint32)(code))) )
-
-#define NS_ERROR_GENERATE_FAILURE(module,code) \
-    ((nsresult) (((PRUint32)(NS_ERROR_SEVERITY_ERROR)<<31) | ((PRUint32)(module+NS_ERROR_MODULE_BASE_OFFSET)<<16) | ((PRUint32)(code))) )
-
-/**
- * @name Standard Macros for retrieving error bits
- */
-
-#define NS_ERROR_GET_CODE(err)     ((err) & 0xffff)
-#define NS_ERROR_GET_MODULE(err)   (((((err) >> 16) - NS_ERROR_MODULE_BASE_OFFSET) & 0x1fff))
-#define NS_ERROR_GET_SEVERITY(err) (((err) >> 31) & 0x1)
-
-/**
- * @name Standard return values
- */
-
-/*@{*/
-
-/* Standard "it worked" return value */
-#define NS_OK                              0
-
-/* The backwards COM false */
-#define NS_COMFALSE                        1
-
-#define NS_ERROR_BASE                      ((nsresult) 0xC1F30000)
-
-/* Returned when an instance is not initialized */
-#define NS_ERROR_NOT_INITIALIZED           (NS_ERROR_BASE + 1)
-
-/* Returned when an instance is already initialized */
-#define NS_ERROR_ALREADY_INITIALIZED       (NS_ERROR_BASE + 2)
-
-/* Returned by a not implemented function */
-#define NS_ERROR_NOT_IMPLEMENTED           ((nsresult) 0x80004001L)
-
-/* Returned when a given interface is not supported. */
-#define NS_NOINTERFACE                     ((nsresult) 0x80004002L)
-#define NS_ERROR_NO_INTERFACE              NS_NOINTERFACE
-
-#define NS_ERROR_INVALID_POINTER           ((nsresult) 0x80004003L)
-#define NS_ERROR_NULL_POINTER              NS_ERROR_INVALID_POINTER
-
-/* Returned when a function aborts */
-#define NS_ERROR_ABORT                     ((nsresult) 0x80004004L)
-
-/* Returned when a function fails */
-#define NS_ERROR_FAILURE                   ((nsresult) 0x80004005L)
-
-/* Returned when an unexpected error occurs */
-#define NS_ERROR_UNEXPECTED                ((nsresult) 0x8000ffffL)
-
-/* Returned when a memory allocation failes */
-#define NS_ERROR_OUT_OF_MEMORY             ((nsresult) 0x8007000eL)
-
-/* Returned when an illegal value is passed */
-#define NS_ERROR_ILLEGAL_VALUE             ((nsresult) 0x80070057L)
-#define NS_ERROR_INVALID_ARG               NS_ERROR_ILLEGAL_VALUE
-
-/* Returned when a class doesn't allow aggregation */
-#define NS_ERROR_NO_AGGREGATION            ((nsresult) 0x80040110L)
-
-/* Returned when a class doesn't allow aggregation */
-#define NS_ERROR_NOT_AVAILABLE             ((nsresult) 0x80040111L)
-
-/* Returned when a class is not registered */
-#define NS_ERROR_FACTORY_NOT_REGISTERED    ((nsresult) 0x80040154L)
-
-/* Returned when a dynamically loaded factory couldn't be found */
-#define NS_ERROR_FACTORY_NOT_LOADED        ((nsresult) 0x800401f8L)
-
-/* Returned when a factory doesn't support signatures */
-#define NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT \
-                                           (NS_ERROR_BASE + 0x101)
-
-/* Returned when a factory already is registered */
-#define NS_ERROR_FACTORY_EXISTS            (NS_ERROR_BASE + 0x100)
-
-/*@}*/
-
-////////////////////////////////////////////////////////////////////////////////
-
-#ifdef XP_PC
-#pragma warning(disable: 4251) // 'nsCOMPtr<class nsIInputStream>' needs to have dll-interface to be used by clients of class 'nsInputStream'
-#pragma warning(disable: 4275) // non dll-interface class 'nsISupports' used as base for dll-interface class 'nsIRDFNode'
-#endif
-
-#endif
-

mozilla/xpcom/base/nsIAllocator.h

@@ -1,108 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsIAllocator_h___
-#define nsIAllocator_h___
-
-#include "nsISupports.h"
-
-/**
- * Unlike IMalloc, this interface returns nsresults and doesn't
- * implement the problematic GetSize and DidAlloc routines.
- */
-
-#define NS_IALLOCATOR_IID                            \
-{ /* 56def700-b1b9-11d2-8177-006008119d7a */         \
-    0x56def700,                                      \
-    0xb1b9,                                          \
-    0x11d2,                                          \
-    {0x81, 0x77, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a} \
-}
-#define NS_ALLOCATOR_PROGID "component://netscape/allocator"
-#define NS_ALLOCATOR_CLASSNAME "Allocator"
-
-class nsIAllocator : public nsISupports {
-public:
-    static const nsIID& GetIID() { static nsIID iid = NS_IALLOCATOR_IID; return iid; }
-    
-    /**
-     * Allocates a block of memory of a particular size. 
-     *
-     * @param size - the size of the block to allocate
-     * @result the block of memory
-     */
-    NS_IMETHOD_(void*) Alloc(PRUint32 size) = 0;
-
-    /**
-     * Reallocates a block of memory to a new size.
-     *
-     * @param ptr - the block of memory to reallocate
-     * @param size - the new size
-     * @result the rellocated block of memory
-     */
-    NS_IMETHOD_(void*) Realloc(void* ptr, PRUint32 size) = 0;
-
-    /**
-     * Frees a block of memory. 
-     *
-     * @param ptr - the block of memory to free
-     * @param size - the size of the block to be freed. If -1 (the default),
-     * the implementation must be able to determine the block size by 
-     * examining the block pointer. 
-     */
-    NS_IMETHOD Free(void* ptr) = 0;
-
-    /**
-     * Attempts to shrink the heap.
-     */
-    NS_IMETHOD HeapMinimize(void) = 0;
-
-};
-
-// To get the global memory manager service:
-#define NS_ALLOCATOR_CID                             \
-{ /* aafe6770-b1bb-11d2-8177-006008119d7a */         \
-    0xaafe6770,                                      \
-    0xb1bb,                                          \
-    0x11d2,                                          \
-    {0x81, 0x77, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a} \
-}
-
-/*
-* Public shortcuts to the shared allocator's methods
-*/
-
-class nsAllocator
-{
-public:
-    static NS_EXPORT void* Alloc(PRUint32 size);
-    static NS_EXPORT void* Realloc(void* ptr, PRUint32 size);
-    static NS_EXPORT void  Free(void* ptr);
-    static NS_EXPORT void  HeapMinimize();
-    static NS_EXPORT void* Clone(const void* ptr,  PRUint32 size);
-private:
-    nsAllocator();   // not implemented
-    static PRBool EnsureAllocator() {return mAllocator || FetchAllocator();}
-    static PRBool FetchAllocator();
-    static nsIAllocator* mAllocator;
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-#endif /* nsIAllocator_h___ */

mozilla/xpcom/base/nsID.cpp

@@ -1,73 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#include "nsID.h"
-#include "prprf.h"
-
-static const char gIDFormat[] = 
-  "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}";
-
-static const char gIDFormat2[] = 
-  "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
-
-/* 
- * Turns a {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} string into
- * an nsID
- */
-
-NS_COM PRBool nsID::Parse(char *aIDStr)
-{
-  PRInt32 count = 0;
-  PRInt32 n1, n2, n3[8];
-  PRInt32 n0;
-
-  if (NULL != aIDStr) {
-    count = PR_sscanf(aIDStr,
-                      (aIDStr[0] == '{') ? gIDFormat : gIDFormat2,
-                      &n0, &n1, &n2, 
-                      &n3[0],&n3[1],&n3[2],&n3[3],
-                      &n3[4],&n3[5],&n3[6],&n3[7]);
-
-    m0 = (PRInt32) n0;
-    m1 = (PRInt16) n1;
-    m2 = (PRInt16) n2;
-    for (int i = 0; i < 8; i++) {
-      m3[i] = (PRInt8) n3[i];
-    }
-  }
-  return (PRBool) (count == 11);
-}
-
-/*
- * Returns an allocated string in {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
- * format. Caller should delete [] the string.
- */
-
-NS_COM char *nsID::ToString() const 
-{
-  char *res = new char[39];
-
-  if (res != NULL) {
-    PR_snprintf(res, 39, gIDFormat,
-                m0, (PRUint32) m1, (PRUint32) m2,
-                (PRUint32) m3[0], (PRUint32) m3[1], (PRUint32) m3[2],
-                (PRUint32) m3[3], (PRUint32) m3[4], (PRUint32) m3[5],
-                (PRUint32) m3[6], (PRUint32) m3[7]);
-  }
-  return res;
-}
-

mozilla/xpcom/base/nsID.h

@@ -1,107 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsID_h__
-#define nsID_h__
-
-#include <string.h>
-
-#ifndef prtypes_h___
-#include "prtypes.h"
-#endif
-
-#ifndef nsCom_h__
-#include "nsCom.h"
-#endif
-
-/**
- * A "unique identifier". This is modeled after OSF DCE UUIDs.
- */
-
-struct nsID {
-  /**
-   * @name Indentifier values
-   */
-
-  //@{
-  PRUint32 m0;
-  PRUint16 m1;
-  PRUint16 m2;
-  PRUint8 m3[8];
-  //@}
-
-  /**
-   * @name Methods
-   */
-
-  //@{
-  /**
-   * Equivalency method. Compares this nsID with another.
-   * @return <b>PR_TRUE</b> if they are the same, <b>PR_FALSE</b> if not.
-   */
-
-  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]));
-  }
-
-  /**
-   * nsID Parsing method. Turns a {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
-   * string into an nsID
-   */
-  NS_COM PRBool Parse(char *aIDStr);
-
-  /**
-   * nsID string encoder. Returns an allocated string in 
-   * {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} format. Caller should free string.
-   */
-  NS_COM char* ToString() const;
-  //@}
-};
-
-/**
- * Declare an ID. If NS_IMPL_IDS is set, a variable <i>_name</i> is declared
- * with the given values, otherwise <i>_name</i> is declared as an 
- * <tt>extern</tt> variable.
- */
-
-#ifdef NS_IMPL_IDS
-#define NS_DECLARE_ID(_name,m0,m1,m2,m30,m31,m32,m33,m34,m35,m36,m37) \
-  extern "C" const nsID _name = {m0,m1,m2,{m30,m31,m32,m33,m34,m35,m36,m37}}
-#else
-#define NS_DECLARE_ID(_name,m0,m1,m2,m30,m31,m32,m33,m34,m35,m36,m37) \
-  extern "C" const nsID _name
-#endif
-
-/*
- * Class IDs
- */
-
-typedef nsID nsCID;
-
-// Define an CID
-#define NS_DEFINE_CID(_name, _cidspec) \
-  const nsCID _name = _cidspec
-
-#define REFNSCID const nsCID&
-
-#endif
-

mozilla/xpcom/base/nsIPtr.h

@@ -1,142 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsIPtr_h___
-#define nsIPtr_h___
-
-#include "nsISupports.h"
-
-/*
- * nsIPtr is an "auto-release pointer" class for nsISupports based interfaces
- *
- * It's intent is to be a "set and forget" pointer to help with managing
- * active references to nsISupports bases objects.
- * 
- * The pointer object ensures that the underlying pointer is always 
- * released whenever the value is changed or when the object leaves scope.
- *
- * Proper care needs to be taken when assigning pointers to a nsIPtr. 
- * When asigning from a C pointer (nsISupports*), the pointer presumes
- * an active reference and subsumes it. When assigning from another nsIPtr,
- * a new reference is established.
- *
- * There are 3 ways to assign a value to a nsIPtr.
- * 1) Direct construction or assignment from a C pointer.
- * 2) Direct construction or assignment form another nsIPtr.
- * 3) Usage of an "out parameter" method.
- *    a) AssignRef() releases the underlying pointer and returns a reference to it.
- *       Useful for pointer reference out paramaters.
- *    b) AssignPtr() releases the underlying pointer and returns a pointer to it.
- *    c) Query() releases the underlying pointer and returns a (void**) pointer to it.
- *       Useful for calls to QueryInterface()
- * 4) The SetAddRef() method. This is equivalent to an assignment followed by an AddRef().
- *
- *    examples:
- *
- *    class It {
- *      void    NS_NewFoo(nsIFoo** aFoo);
- *      nsIFoo* GetFoo(void);
- *      void    GetBar(nsIBar*& aBar);
- *    };
- *
- *    nsIFooPtr foo = it->GetFoo();
- *    nsIBarPtr bar;
- *
- *    it->NS_NewFoo(foo.AssignPtr());
- *    it->GetBar(bar.AssignRef());
- *    it->QueryInterface(kIFooIID, foo.Query());
- *    bar.SetAddRef(new Bar());
- *
- * Advantages:
- * Set and forget. Once a pointer is assigned to a nsIPtr, it is impossible
- * to forget to release it.
- * Always pre-initialized. You can't forget to initialize the pointer.
- *
- * Disadvantages:
- * Usage of this class doesn't eliminate the need to think about ref counts
- * and assign values properly, AddRef'ing as needed. 
- * The nsIPtr doesn't typecast exactly like a C pointer. In order to achieve
- * typecasting, it may be necessary to first cast to a C pointer of the 
- * underlying type.
- *
- */
-
-#define NS_DEF_PTR(cls)                                                       \
-class cls##Ptr {                                                              \
-public:                                                                       \
-  cls##Ptr(void)  : mPtr(0) {}                                                \
-  cls##Ptr(const cls##Ptr& aCopy) : mPtr(aCopy.mPtr)                          \
-    { NS_IF_ADDREF(mPtr);  }                                                  \
-  cls##Ptr(cls* aInterface)       : mPtr(aInterface)  {}                      \
-  ~cls##Ptr(void)     { NS_IF_RELEASE(mPtr);  }                               \
-  cls##Ptr& operator=(const cls##Ptr& aCopy)                                  \
-    { if(mPtr == aCopy.mPtr) return *this;                                    \
-      NS_IF_ADDREF(aCopy.mPtr);                                               \
-      NS_IF_RELEASE(mPtr);                                                    \
-      mPtr = aCopy.mPtr;  return *this; }                                     \
-  cls##Ptr& operator=(cls* aInterface)                                        \
-    { if(mPtr == aInterface) return *this;                                    \
-      NS_IF_RELEASE(mPtr); mPtr = aInterface;                                 \
-      return *this; }                                                         \
-  cls##Ptr& operator=(PRInt32 aInt)                                           \
-    { NS_IF_RELEASE(mPtr);                                                    \
-      return *this; }                                                         \
-  void  SetAddRef(cls* aInterface)                                            \
-    { if(aInterface == mPtr)  return;                                         \
-      NS_IF_ADDREF(aInterface);                                               \
-      NS_IF_RELEASE(mPtr); mPtr = aInterface;  }                              \
-  cls*  AddRef(void)  { NS_ADDREF(mPtr); return mPtr;  }                      \
-  cls*  IfAddRef(void)                                                        \
-    { NS_IF_ADDREF(mPtr); return mPtr;  }                                     \
-  cls*& AssignRef(void)                                                       \
-    { NS_IF_RELEASE(mPtr);  return mPtr; }                                    \
-  cls** AssignPtr(void)                                                       \
-    { NS_IF_RELEASE(mPtr);  return &mPtr; }                                   \
-  void** Query(void)                                                          \
-    { NS_IF_RELEASE(mPtr);  return (void**)&mPtr; }                           \
-  PRBool  IsNull() const                                                      \
-    { return PRBool(0 == mPtr); }                                             \
-  PRBool  IsNotNull() const                                                   \
-    { return PRBool(0 != mPtr); }                                             \
-  PRBool  operator==(const cls##Ptr& aCopy) const                             \
-    { return PRBool(mPtr == aCopy.mPtr);  }                                   \
-  PRBool  operator==(cls* aInterface) const                                   \
-    { return PRBool(mPtr == aInterface);  }                                   \
-  PRBool  operator!=(const cls##Ptr& aCopy) const                             \
-    { return PRBool(mPtr != aCopy.mPtr);  }                                   \
-  PRBool  operator!=(cls* aInterface) const                                   \
-    { return PRBool(mPtr != aInterface);  }                                   \
-  cls*  operator->(void)  { return mPtr;  }                                   \
-  cls&  operator*(void)   { return *mPtr; }                                   \
-  operator cls*(void)     { return mPtr;  }                                   \
-  const cls*  operator->(void) const  { return mPtr;  }                       \
-  const cls&  operator*(void) const   { return *mPtr; }                       \
-  operator const cls* (void) const    { return mPtr;  }                       \
-private:                                                                      \
-  void* operator new(size_t size) { return 0; }                               \
-  void operator delete(void* aPtr)  {}                                        \
-  cls*  mPtr;                                                                 \
-public:                                                                       \
-friend inline PRBool operator==(const cls* aInterface, const cls##Ptr& aPtr)  \
-{ return PRBool(aInterface == aPtr.mPtr); }                                   \
-friend inline PRBool operator!=(const cls* aInterface, const cls##Ptr& aPtr)  \
-{ return PRBool(aInterface != aPtr.mPtr); }                                   \
-}
-
-#endif // nsIPtr_h___
-

mozilla/xpcom/base/nsISupports.idl

@@ -1,56 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-/* The mother of all xpcom interfaces. */
-
-/* In order to get both the right typelib and the right header we force
-*  the 'real' output from xpidl to be commentout out in the generated header
-*  and includes a copy of the original nsISUpports.h. This is all just to deal 
-*  with the Mac specific ": public __comobject" thing.
-*/
-
-#include "nsrootidl.idl"
-
-%{C++
-/* 
- * Start commenting out the C++ versions of the below in the output header
- */
-#if 0
-%}
-
-[scriptable, uuid(00000000-0000-0000-c000-000000000046)]
-interface nsISupports {
-  void QueryInterface(in nsIIDRef uuid, 
-                      [iid_is(uuid),retval] out nsQIResult result);
-  [noscript, notxpcom] nsrefcnt AddRef();
-  [noscript, notxpcom] nsrefcnt Release();
-};
-
-%{C++
-/* 
- * End commenting out the C++ versions of the above in the output header
- */
-#endif
-%}
-
-
-%{C++
-
-#include "nsISupportsUtils.h"
-
-%}

mozilla/xpcom/base/nsISupportsUtils.h

@@ -1,756 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef __nsISupportsUtils_h
-#define __nsISupportsUtils_h
-
-/***************************************************************************/
-/* this section copied from the hand written nsISupports.h */
-
-#include "nsDebug.h"
-#include "nsID.h"
-#include "nsIID.h"
-#include "nsError.h"
-
-#if defined(NS_MT_SUPPORTED)
-#include "prcmon.h"
-#endif  /* NS_MT_SUPPORTED */
-
-#if defined(XPIDL_JS_STUBS)
-struct JSObject;
-struct JSContext;
-#endif
-
-  // under Metrowerks (Mac), we don't have autoconf yet
-#ifdef __MWERKS__
-  #define HAVE_CPP_SPECIALIZATION
-#endif
-
-  // under VC++ (Windows), we don't have autoconf yet
-#if defined(_MSC_VER) && (_MSC_VER>=1100)
-		// VC++ 5.0 and greater implement template specialization, 4.2 is unknown
-  #define HAVE_CPP_SPECIALIZATION
-#endif
-
-#ifdef HAVE_CPP_SPECIALIZATION
-	#define NSCAP_FEATURE_HIDE_NSISUPPORTS_GETIID
-#endif
-
-/*@{*/
-
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * IID for the nsISupports interface
- * {00000000-0000-0000-c000-000000000046}
- *
- * To maintain binary compatibility with COM's nsIUnknown, we define the IID
- * of nsISupports to be the same as that of COM's nsIUnknown.
- */
-#define NS_ISUPPORTS_IID      \
-{ 0x00000000, 0x0000, 0x0000, \
-  {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }
-
-/**
- * Reference count values
- *
- * This is type of return value from Addref() and Release() in nsISupports.
- * nsIUnknown of COM returns a unsigned long from equivalent functions.
- * To maintain binary compatibility of nsISupports with nsIUnknown, we are
- * doing this ifdeffing.
- */
-#if defined(XP_PC) && PR_BYTES_PER_LONG == 4
-typedef unsigned long nsrefcnt;
-#else
-typedef PRUint32 nsrefcnt;
-#endif
-
-#include "nsTraceRefcnt.h"
-
-/**
- * Base class for all XPCOM objects to use. This macro forces the C++
- * compiler to use a compatible vtable layout for all XPCOM objects.
- */
-#ifdef XP_MAC
-#define XPCOM_OBJECT : public __comobject
-#else
-#define XPCOM_OBJECT
-#endif
-
-/**
- * Basic component object model interface. Objects which implement
- * this interface support runtime interface discovery (QueryInterface)
- * and a reference counted memory model (AddRef/Release). This is
- * modelled after the win32 IUnknown API.
- */
-class nsISupports XPCOM_OBJECT {
-public:
-
-#ifndef NSCAP_FEATURE_HIDE_NSISUPPORTS_GETIID
-  static const nsIID& GetIID() { static nsIID iid = NS_ISUPPORTS_IID; return iid; }
-#endif
-
-  /**
-   * @name Methods
-   */
-
-  //@{
-  /**
-   * A run time mechanism for interface discovery.
-   * @param aIID [in] A requested interface IID
-   * @param aInstancePtr [out] A pointer to an interface pointer to
-   * receive the result.
-   * @return <b>NS_OK</b> if the interface is supported by the associated
-   * instance, <b>NS_NOINTERFACE</b> if it is not. 
-   * <b>NS_ERROR_INVALID_POINTER</b> if <i>aInstancePtr</i> is <b>NULL</b>.
-   */
-  NS_IMETHOD QueryInterface(REFNSIID aIID,
-                            void** aInstancePtr) = 0;
-  /**
-   * Increases the reference count for this interface.
-   * The associated instance will not be deleted unless
-   * the reference count is returned to zero.
-   *
-   * @return The resulting reference count.
-   */
-  NS_IMETHOD_(nsrefcnt) AddRef(void) = 0;
-
-  /**
-   * Decreases the reference count for this interface.
-   * Generally, if the reference count returns to zero,
-   * the associated instance is deleted.
-   *
-   * @return The resulting reference count.
-   */
-  NS_IMETHOD_(nsrefcnt) Release(void) = 0;
-
-  //@}
-};
-
-/*@}*/
-
-/***************************************************************************/
-
-/**
- * A macro to build the static const IID accessor method
- */
-
-#define NS_DEFINE_STATIC_IID_ACCESSOR(the_iid) \
-  static const nsIID& GetIID() {static nsIID iid = the_iid; return iid;}
-
-/**
- * A macro to build the static const CID accessor method
- */
-
-#define NS_DEFINE_STATIC_CID_ACCESSOR(the_cid) \
-  static const nsID& GetCID() {static nsID cid = the_cid; return cid;}
-
-/**
- * Some convenience macros for implementing AddRef and Release
- */
-
-/**
- * Declare the reference count variable and the implementations of the
- * AddRef and QueryInterface methods.
- */
-
-#define NS_DECL_ISUPPORTS                                                   \
-public:                                                                     \
-  NS_IMETHOD QueryInterface(REFNSIID aIID,                                  \
-                            void** aInstancePtr);                           \
-  NS_IMETHOD_(nsrefcnt) AddRef(void);                                       \
-  NS_IMETHOD_(nsrefcnt) Release(void);                                      \
-protected:                                                                  \
-  nsrefcnt mRefCnt;                                                         \
-public:
-
-#define NS_DECL_ISUPPORTS_EXPORTED                                          \
-public:                                                                     \
-  NS_EXPORT NS_IMETHOD QueryInterface(REFNSIID aIID,                        \
-                            void** aInstancePtr);                           \
-  NS_EXPORT NS_IMETHOD_(nsrefcnt) AddRef(void);                             \
-  NS_EXPORT NS_IMETHOD_(nsrefcnt) Release(void);                            \
-protected:                                                                  \
-  nsrefcnt mRefCnt;                                                         \
-public:
-
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Initialize the reference count variable. Add this to each and every
- * constructor you implement.
- */
-#define NS_INIT_REFCNT() mRefCnt = 0
-#define NS_INIT_ISUPPORTS() NS_INIT_REFCNT() // what it should have been called in the first place
-
-/**
- * Use this macro to implement the AddRef method for a given <i>_class</i>
- * @param _class The name of the class implementing the method
- */
-#define NS_IMPL_ADDREF(_class)                               \
-NS_IMETHODIMP_(nsrefcnt) _class::AddRef(void)                \
-{                                                            \
-  NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");  \
-  ++mRefCnt;                                                 \
-  NS_LOG_ADDREF(this, mRefCnt, __FILE__, __LINE__);          \
-  return mRefCnt;                                            \
-}
-
-/**
- * Use this macro to implement the Release method for a given <i>_class</i>
- * @param _class The name of the class implementing the method
- */
-#define NS_IMPL_RELEASE(_class)                        \
-NS_IMETHODIMP_(nsrefcnt) _class::Release(void)         \
-{                                                      \
-  NS_PRECONDITION(0 != mRefCnt, "dup release");        \
-  --mRefCnt;                                           \
-  NS_LOG_RELEASE(this, mRefCnt, __FILE__, __LINE__);   \
-  if (mRefCnt == 0) {                                  \
-    NS_DELETEXPCOM(this);                              \
-    return 0;                                          \
-  }                                                    \
-  return mRefCnt;                                      \
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/*
- * Some convenience macros for implementing QueryInterface
- */
-
-/** 
- * This implements query interface with two assumptions: First, the
- * class in question implements nsISupports and it's own interface and
- * nothing else. Second, the implementation of the class's primary
- * inheritance chain leads to it's own interface.
- *
- * @param _class The name of the class implementing the method
- * @param _classiiddef The name of the #define symbol that defines the IID
- * for the class (e.g. NS_ISUPPORTS_IID)
- */
-
-#define NS_IMPL_QUERY_INTERFACE(_class,_classiiddef)                     \
-NS_IMETHODIMP _class::QueryInterface(REFNSIID aIID, void** aInstancePtr)      \
-{                                                                        \
-  if (NULL == aInstancePtr) {                                            \
-    return NS_ERROR_NULL_POINTER;                                        \
-  }                                                                      \
-                                                                         \
-  *aInstancePtr = NULL;                                                  \
-                                                                         \
-  static NS_DEFINE_IID(kClassIID, _classiiddef);                         \
-  if (aIID.Equals(kClassIID)) {                                          \
-    *aInstancePtr = (void*) this;                                        \
-    NS_ADDREF_THIS();                                                    \
-    return NS_OK;                                                        \
-  }                                                                      \
-  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {               \
-    *aInstancePtr = (void*) ((nsISupports*)this);                        \
-    NS_ADDREF_THIS();                                                    \
-    return NS_OK;                                                        \
-  }                                                                      \
-  return NS_NOINTERFACE;                                                 \
-}
-
-/**
- * Convenience macro for implementing all nsISupports methods for
- * a simple class.
- * @param _class The name of the class implementing the method
- * @param _classiiddef The name of the #define symbol that defines the IID
- * for the class (e.g. NS_ISUPPORTS_IID)
- */
-
-#define NS_IMPL_ISUPPORTS(_class,_classiiddef) \
-  NS_IMPL_ADDREF(_class)                       \
-  NS_IMPL_RELEASE(_class)                      \
-  NS_IMPL_QUERY_INTERFACE(_class,_classiiddef)
-
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Declare that you're going to inherit from something that already
- * implements nsISupports, but also implements an additional interface, thus
- * causing an ambiguity. In this case you don't need another mRefCnt, you 
- * just need to forward the definitions to the appropriate superclass. E.g.
- *
- * class Bar : public Foo, public nsIBar {  // both provide nsISupports
- * public: 
- *   NS_DECL_ISUPPORTS_INHERITED
- *   ...other nsIBar and Bar methods...
- * };
- */
-#define NS_DECL_ISUPPORTS_INHERITED                                         \
-public:                                                                     \
-  NS_IMETHOD QueryInterface(REFNSIID aIID,                                  \
-                            void** aInstancePtr);                           \
-  NS_IMETHOD_(nsrefcnt) AddRef(void);                                       \
-  NS_IMETHOD_(nsrefcnt) Release(void);                                      \
-
-/**
- * These macros can be used in conjunction with NS_DECL_ISUPPORTS_INHERITED
- * to implement the nsISupports methods, forwarding the invocations to a
- * superclass that already implements nsISupports. 
- *
- * Note that I didn't make these inlined because they're virtual methods.
- */
-
-#define NS_IMPL_ADDREF_INHERITED(Class, Super)                                \
-NS_IMETHODIMP_(nsrefcnt) Class::AddRef(void)                                                  \
-{                                                                             \
-  return Super::AddRef();                                                     \
-}                                                                             \
-
-#define NS_IMPL_RELEASE_INHERITED(Class, Super)                               \
-NS_IMETHODIMP_(nsrefcnt) Class::Release(void)                                                 \
-{                                                                             \
-  return Super::Release();                                                    \
-}                                                                             \
-
-#define NS_IMPL_QUERY_INTERFACE_INHERITED(Class, Super, AdditionalInterface)  \
-NS_IMETHODIMP Class::QueryInterface(REFNSIID aIID, void** aInstancePtr)            \
-{                                                                             \
-  if (!aInstancePtr) return NS_ERROR_NULL_POINTER;                            \
-  if (aIID.Equals(AdditionalInterface::GetIID())) {                           \
-    *aInstancePtr = NS_STATIC_CAST(AdditionalInterface*, this);               \
-    NS_ADDREF_THIS();                                                         \
-    return NS_OK;                                                             \
-  }                                                                           \
-  return Super::QueryInterface(aIID, aInstancePtr);                           \
-}                                                                             \
-
-#define NS_IMPL_ISUPPORTS_INHERITED(Class, Super, AdditionalInterface)        \
-    NS_IMPL_QUERY_INTERFACE_INHERITED(Class, Super, AdditionalInterface)      \
-    NS_IMPL_ADDREF_INHERITED(Class, Super)                                    \
-    NS_IMPL_RELEASE_INHERITED(Class, Super)                                   \
-
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- *
- * Threadsafe implementations of the ISupports convenience macros
- *
- */
-
-/**
- * IID for the nsIsThreadsafe interface
- * {88210890-47a6-11d2-bec3-00805f8a66dc}
- *
- * This interface is *only* used for debugging purposes to determine if
- * a given component is threadsafe.
- */
-#define NS_ISTHREADSAFE_IID      \
-{ 0x88210890, 0x47a6, 0x11d2,    \
-  {0xbe, 0xc3, 0x00, 0x80, 0x5f, 0x8a, 0x66, 0xdc} }
-
-#if defined(NS_MT_SUPPORTED)
-
-#define NS_LOCK_INSTANCE()                                                  \
-  PR_CEnterMonitor((void*)this)
-
-#define NS_UNLOCK_INSTANCE()                                                \
-  PR_CExitMonitor((void*)this)
-
-/**
- * Use this macro to implement the AddRef method for a given <i>_class</i>
- * @param _class The name of the class implementing the method
- */
-#if defined(XP_PC)
-#define NS_IMPL_THREADSAFE_ADDREF(_class)                                   \
-NS_IMETHODIMP_(nsrefcnt) _class::AddRef(void)                                               \
-{                                                                           \
-  NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");                 \
-  return InterlockedIncrement((LONG*)&mRefCnt);                             \
-}
-
-#else /* ! XP_PC */
-#define NS_IMPL_THREADSAFE_ADDREF(_class)                                   \
-nsrefcnt _class::AddRef(void)                                               \
-{                                                                           \
-  nsrefcnt count;                                                           \
-  NS_LOCK_INSTANCE();                                                       \
-  NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");                 \
-  count = ++mRefCnt;                                                        \
-  NS_UNLOCK_INSTANCE();                                                     \
-  return count;                                                             \
-}
-#endif /* ! XP_PC */
-
-/**
- * Use this macro to implement the Release method for a given <i>_class</i>
- * @param _class The name of the class implementing the method
- */
-#if defined(XP_PC)
-#define NS_IMPL_THREADSAFE_RELEASE(_class)             \
-NS_IMETHODIMP_(nsrefcnt) _class::Release(void)                         \
-{                                                      \
-  NS_PRECONDITION(0 != mRefCnt, "dup release");        \
-  if (0 == InterlockedDecrement((LONG*)&mRefCnt)) {    \
-    NS_DELETEXPCOM(this);                              \
-    return 0;                                          \
-  }                                                    \
-  return mRefCnt; /* Not threadsafe but who cares. */  \
-}
-
-#else /* ! XP_PC */
-#define NS_IMPL_THREADSAFE_RELEASE(_class)             \
-nsrefcnt _class::Release(void)                         \
-{                                                      \
-  nsrefcnt count;                                      \
-  NS_PRECONDITION(0 != mRefCnt, "dup release");        \
-  NS_LOCK_INSTANCE();                                  \
-  count = --mRefCnt;                                   \
-  NS_UNLOCK_INSTANCE();                                \
-  if (0 == count) {                                    \
-    NS_DELETEXPCOM(this);                              \
-    return 0;                                          \
-  }                                                    \
-  return count;                                        \
-}
-#endif /* ! XP_PC */
-
-////////////////////////////////////////////////////////////////////////////////
-
-/*
- * Some convenience macros for implementing QueryInterface
- */
-
-/** 
- * This implements query interface with two assumptions: First, the
- * class in question implements nsISupports and it's own interface and
- * nothing else. Second, the implementation of the class's primary
- * inheritance chain leads to it's own interface.
- *
- * @param _class The name of the class implementing the method
- * @param _classiiddef The name of the #define symbol that defines the IID
- * for the class (e.g. NS_ISUPPORTS_IID)
- */
-#if defined(NS_DEBUG)
-#define NS_VERIFY_THREADSAFE_INTERFACE(_iface)                              \
- if (NULL != (_iface)) {                                                    \
-   nsISupports* tmp;                                                        \
-   static NS_DEFINE_IID(kIsThreadsafeIID, NS_ISTHREADSAFE_IID);             \
-   NS_PRECONDITION((NS_OK == _iface->QueryInterface(kIsThreadsafeIID,       \
-                                                    (void**)&tmp)),         \
-                   "Interface is not threadsafe");                          \
- }
-
-#define NS_IMPL_THREADSAFE_QUERY_INTERFACE(_class,_classiiddef)          \
-NS_IMETHODIMP _class::QueryInterface(REFNSIID aIID, void** aInstancePtr)      \
-{                                                                        \
-  if (NULL == aInstancePtr) {                                            \
-    return NS_ERROR_NULL_POINTER;                                        \
-  }                                                                      \
-                                                                         \
-  *aInstancePtr = NULL;                                                  \
-                                                                         \
-  static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 \
-  static NS_DEFINE_IID(kIsThreadsafeIID, NS_ISTHREADSAFE_IID);           \
-  static NS_DEFINE_IID(kClassIID, _classiiddef);                         \
-  if (aIID.Equals(kClassIID)) {                                          \
-    *aInstancePtr = (void*) this;                                        \
-    NS_ADDREF_THIS();                                                    \
-    return NS_OK;                                                        \
-  }                                                                      \
-  if (aIID.Equals(kISupportsIID)) {                                      \
-    *aInstancePtr = (void*) ((nsISupports*)this);                        \
-    NS_ADDREF_THIS();                                                    \
-    return NS_OK;                                                        \
-  }                                                                      \
-  if (aIID.Equals(kIsThreadsafeIID)) {                                   \
-    return NS_OK;                                                        \
-  }                                                                      \
-  return NS_NOINTERFACE;                                                 \
-}
-
-#else   /* !NS_DEBUG */
-
-#define NS_VERIFY_THREADSAFE_INTERFACE(_iface)
-#define NS_IMPL_THREADSAFE_QUERY_INTERFACE(_class,_classiiddef)          \
- NS_IMPL_QUERY_INTERFACE(_class, _classiiddef)
-
-#endif /* !NS_DEBUG */
-
-/**
- * Convenience macro for implementing all nsISupports methods for
- * a simple class.
- * @param _class The name of the class implementing the method
- * @param _classiiddef The name of the #define symbol that defines the IID
- * for the class (e.g. NS_ISUPPORTS_IID)
- */
-
-#define NS_IMPL_THREADSAFE_ISUPPORTS(_class,_classiiddef) \
-  NS_IMPL_THREADSAFE_ADDREF(_class)                       \
-  NS_IMPL_THREADSAFE_RELEASE(_class)                      \
-  NS_IMPL_THREADSAFE_QUERY_INTERFACE(_class,_classiiddef)
-
-#else /* !NS_MT_SUPPORTED */
-
-#define NS_LOCK_INSTANCE()
-
-#define NS_UNLOCK_INSTANCE()
-
-#define NS_IMPL_THREADSAFE_ADDREF(_class)  NS_IMPL_ADDREF(_class)
-
-#define NS_IMPL_THREADSAFE_RELEASE(_class) NS_IMPL_RELEASE(_class)
-
-#define NS_VERIFY_THREADSAFE_INTERFACE(_iface)
-
-#define NS_IMPL_THREADSAFE_QUERY_INTERFACE(_class,_classiiddef) \
- NS_IMPL_QUERY_INTERFACE(_class, _classiiddef)
-
-#define NS_IMPL_THREADSAFE_ISUPPORTS(_class,_classiiddef) \
-  NS_IMPL_ADDREF(_class)                                  \
-  NS_IMPL_RELEASE(_class)                                 \
-  NS_IMPL_QUERY_INTERFACE(_class,_classiiddef)
-
-#endif /* !NS_MT_SUPPORTED */
-
-////////////////////////////////////////////////////////////////////////////////
-// Debugging Macros
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Macro for instantiating a new object that implements nsISupports.
- * Use this in your factory methods to allow for refcnt tracing.
- * Note that you can only use this if you adhere to the no arguments
- * constructor com policy (which you really should!).
- * @param _result Where the new instance pointer is stored
- * @param _type The type of object to call "new" with.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_NEWXPCOM(_result,_type)                              \
-  PR_BEGIN_MACRO                                                \
-    _result = new _type();                                      \
-    nsTraceRefcnt::Create(_result, #_type, __FILE__, __LINE__); \
-  PR_END_MACRO
-#else
-#define NS_NEWXPCOM(_result,_type) \
-  _result = new _type()
-#endif
-
-/**
- * Macro for deleting an object that implements nsISupports.
- * Use this in your Release methods to allow for refcnt tracing.
- * @param _ptr The object to delete.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_DELETEXPCOM(_ptr)                            \
-  PR_BEGIN_MACRO                                        \
-    nsTraceRefcnt::Destroy((_ptr), __FILE__, __LINE__); \
-    delete (_ptr);                                      \
-  PR_END_MACRO
-#else
-#define NS_DELETEXPCOM(_ptr)    \
-  delete (_ptr)
-#endif
-
-/**
- * Macro for adding a reference to an interface.
- * @param _ptr The interface pointer.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_ADDREF(_ptr)                                       \
-  ((nsrefcnt) nsTraceRefcnt::AddRef((_ptr), (_ptr)->AddRef(), \
-                                    __FILE__, __LINE__))
-#else
-#define NS_ADDREF(_ptr) \
-  (_ptr)->AddRef()
-#endif
-
-/**
- * Macro for adding a reference to this. This macro should be used
- * because NS_ADDREF (when tracing) may require an ambiguous cast
- * from the pointers primary type to nsISupports. This macro sidesteps
- * that entire problem.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_ADDREF_THIS() \
-  ((nsrefcnt) nsTraceRefcnt::AddRef(this, AddRef(), __FILE__, __LINE__))
-#else
-#define NS_ADDREF_THIS() \
-  AddRef()
-#endif
-
-/**
- * Macro for adding a reference to an interface that checks for NULL.
- * @param _ptr The interface pointer.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_IF_ADDREF(_ptr)                                                 \
-  ((0 != (_ptr))                                                           \
-   ? ((nsrefcnt) nsTraceRefcnt::AddRef((_ptr), (_ptr)->AddRef(), __FILE__, \
-                                       __LINE__))                          \
-   : 0)
-#else
-#define NS_IF_ADDREF(_ptr) \
-  ((0 != (_ptr)) ? (_ptr)->AddRef() : 0)
-#endif
-
-/**
- * Macro for releasing a reference to an interface.
- *
- * Note that when MOZ_TRACE_XPCOM_REFCNT is defined that the release will
- * be done before the trace message is logged. If the reference count
- * goes to zero and implementation of Release logs a message, the two
- * messages will be logged out of order.
- *
- * @param _ptr The interface pointer.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_RELEASE(_ptr)                                                   \
-  PR_BEGIN_MACRO                                                           \
-    nsTraceRefcnt::Release((_ptr), (_ptr)->Release(), __FILE__, __LINE__); \
-    (_ptr) = 0;                                                            \
-  PR_END_MACRO
-#else
-#define NS_RELEASE(_ptr)    \
-  PR_BEGIN_MACRO            \
-    (_ptr)->Release();      \
-    (_ptr) = 0;             \
-  PR_END_MACRO
-#endif
-
-/**
- * Macro for releasing a reference to an interface.
- *
- * Note that when MOZ_TRACE_XPCOM_REFCNT is defined that the release will
- * be done before the trace message is logged. If the reference count
- * goes to zero and implementation of Release logs a message, the two
- * messages will be logged out of order.
- *
- * @param _ptr The interface pointer.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_RELEASE_THIS()                                                  \
-    nsTraceRefcnt::Release(this, Release(), __FILE__, __LINE__)
-#else
-#define NS_RELEASE_THIS()    \
-    Release()
-#endif
-
-/**
- * Macro for releasing a reference to an interface, except that this
- * macro preserves the return value from the underlying Release call.
- * The interface pointer argument will only be NULLed if the reference count
- * goes to zero.
- *
- * Note that when MOZ_TRACE_XPCOM_REFCNT is defined that the release will
- * be done before the trace message is logged. If the reference count
- * goes to zero and implementation of Release logs a message, the two
- * messages will be logged out of order.
- *
- * @param _ptr The interface pointer.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_RELEASE2(_ptr, _result)                                          \
-  PR_BEGIN_MACRO                                                            \
-    _result = ((nsrefcnt) nsTraceRefcnt::Release((_ptr), (_ptr)->Release(), \
-                                                 __FILE__, __LINE__));      \
-    if (0 == (_result)) (_ptr) = 0;                                         \
-  PR_END_MACRO
-#else
-#define NS_RELEASE2(_ptr, _result)  \
-  PR_BEGIN_MACRO                    \
-    _result = (_ptr)->Release();    \
-    if (0 == (_result)) (_ptr) = 0; \
-  PR_END_MACRO
-#endif
-
-/**
- * Macro for releasing a reference to an interface that checks for NULL;
- *
- * Note that when MOZ_TRACE_XPCOM_REFCNT is defined that the release will
- * be done before the trace message is logged. If the reference count
- * goes to zero and implementation of Release logs a message, the two
- * messages will be logged out of order.
- *
- * @param _ptr The interface pointer.
- */
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#define NS_IF_RELEASE(_ptr)                                         \
-  PR_BEGIN_MACRO                                                    \
-    ((0 != (_ptr))                                                  \
-    ? ((nsrefcnt) nsTraceRefcnt::Release((_ptr), (_ptr)->Release(), \
-                                          __FILE__, __LINE__))      \
-    : 0);                                                           \
-    (_ptr) = 0;                                                     \
-  PR_END_MACRO
-#else
-#define NS_IF_RELEASE(_ptr)                   \
-  PR_BEGIN_MACRO                              \
-    ((0 != (_ptr)) ? (_ptr)->Release() : 0);  \
-    (_ptr) = 0;                               \
-  PR_END_MACRO
-#endif
-
-#ifdef MOZ_LOG_REFCNT
-#define NS_LOG_ADDREF(_ptr, _refcnt, _file, _line) \
-  nsTraceRefcnt::LogAddRef((_ptr), (_refcnt), (_file), (_line))
-
-#define NS_LOG_RELEASE(_ptr, _refcnt, _file, _line) \
-  nsTraceRefcnt::LogRelease((_ptr), (_refcnt), (_file), (_line))
-
-#else
-#define NS_LOG_ADDREF(_file, _line, _ptr, _refcnt)
-#define NS_LOG_RELEASE(_file, _line, _ptr, _refcnt)
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-// A type-safe interface for calling |QueryInterface()|.  A similar implementation
-//	exists in "nsCOMPtr.h" for use with |nsCOMPtr|s.
-
-extern "C++" {
-	// ...because some one is accidentally including this file inside an |extern "C"|
-
-class nsISupports;
-
-template <class T>
-struct nsCOMTypeInfo
-	{
-		static const nsIID& GetIID() { return T::GetIID(); }
-	};
-
-#ifdef NSCAP_FEATURE_HIDE_NSISUPPORTS_GETIID
-	template <>
-	struct nsCOMTypeInfo<nsISupports>
-		{
-			static const nsIID& GetIID() { static nsIID iid = NS_ISUPPORTS_IID; return iid; }
-		};
-#endif
-
-#define NS_GET_IID(T) nsCOMTypeInfo<T>::GetIID()
-
-template <class DestinationType>
-inline
-nsresult
-CallQueryInterface( nsISupports* aSource, DestinationType** aDestination )
-		// a type-safe shortcut for calling the |QueryInterface()| member function
-	{
-		NS_PRECONDITION(aSource, "null parameter");
-    NS_PRECONDITION(aDestination, "null parameter");
-
-		return aSource->QueryInterface(nsCOMTypeInfo<DestinationType>::GetIID(), (void**)aDestination);
-	}
-
-} // extern "C++"
-
-////////////////////////////////////////////////////////////////////////////////
-
-#endif /* __nsISupportsUtils_h */

mozilla/xpcom/base/nsTraceRefcnt.cpp

@@ -1,486 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License.  You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#include "nsISupports.h"
-#include "prprf.h"
-#include "prlog.h"
-
-#if defined(_WIN32)
-#include <windows.h>
-#elif defined(linux) && defined(__GLIBC__) && defined(__i386)
-#include <setjmp.h>
-
-//
-// On glibc 2.1, the Dl_info api defined in <dlfcn.h> is only exposed
-// if __USE_GNU is defined.  I suppose its some kind of standards
-// adherence thing.
-//
-#if (__GLIBC_MINOR__ >= 1)
-#define __USE_GNU
-#endif
-
-#include <dlfcn.h>
-
-#endif
-
-#if defined(NS_MT_SUPPORTED)
-#include "prlock.h"
-
-static PRLock* gTraceLock;
-
-#define LOCK_TRACELOG()   PR_Lock(gTraceLock)
-#define UNLOCK_TRACELOG() PR_Unlock(gTraceLock)
-#else /* ! NT_MT_SUPPORTED */
-#define LOCK_TRACELOG()
-#define UNLOCK_TRACELOG()
-#endif /* ! NS_MT_SUPPORTED */
-
-static PRLogModuleInfo* gTraceRefcntLog;
-
-static void InitTraceLog(void)
-{
-  if (0 == gTraceRefcntLog) {
-    gTraceRefcntLog = PR_NewLogModule("xpcomrefcnt");
-
-#if defined(NS_MT_SUPPORTED)
-    gTraceLock = PR_NewLock();
-#endif /* NS_MT_SUPPORTED */
-  }
-}
-
-
-int nsIToA16(PRUint32 aNumber, char* aBuffer)
-{
-  static char kHex[] = "0123456789abcdef";
-
-  if (aNumber == 0) {
-    *aBuffer = '0';
-    return 1;
-  }
-
-  char buf[8];
-  PRInt32 count = 0;
-  while (aNumber != 0) {
-    PRUint32 nibble = aNumber & 0xf;
-    buf[count++] = kHex[nibble];
-    aNumber >>= 4;
-  }
-
-  for (PRInt32 i = count - 1; i >= 0; --i)
-    *aBuffer++ = buf[i];
-
-  return count;
-}
-
-#if defined(_WIN32) // WIN32 stack walking code
-#include "imagehlp.h"
-#include <stdio.h>
-
-// Define these as static pointers so that we can load the DLL on the
-// fly (and not introduce a link-time dependency on it). Tip o' the
-// hat to Matt Pietrick for this idea. See:
-//
-//   http://msdn.microsoft.com/library/periodic/period97/F1/D3/S245C6.htm
-//
-typedef BOOL (__stdcall *SYMINITIALIZEPROC)(HANDLE, LPSTR, BOOL);
-static SYMINITIALIZEPROC _SymInitialize;
-
-typedef BOOL (__stdcall *SYMCLEANUPPROC)(HANDLE);
-static SYMCLEANUPPROC _SymCleanup;
-
-typedef BOOL (__stdcall *STACKWALKPROC)(DWORD,
-                                        HANDLE,
-                                        HANDLE,
-                                        LPSTACKFRAME,
-                                        LPVOID,
-                                        PREAD_PROCESS_MEMORY_ROUTINE,
-                                        PFUNCTION_TABLE_ACCESS_ROUTINE,
-                                        PGET_MODULE_BASE_ROUTINE,
-                                        PTRANSLATE_ADDRESS_ROUTINE);
-static STACKWALKPROC _StackWalk;
-
-typedef LPVOID (__stdcall *SYMFUNCTIONTABLEACCESSPROC)(HANDLE, DWORD);
-static SYMFUNCTIONTABLEACCESSPROC _SymFunctionTableAccess;
-
-typedef DWORD (__stdcall *SYMGETMODULEBASEPROC)(HANDLE, DWORD);
-static SYMGETMODULEBASEPROC _SymGetModuleBase;
-
-typedef BOOL (__stdcall *SYMGETSYMFROMADDRPROC)(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
-static SYMGETSYMFROMADDRPROC _SymGetSymFromAddr;
-
-
-static PRBool
-EnsureSymInitialized()
-{
-  PRBool gInitialized = PR_FALSE;
-
-  if (! gInitialized) {
-    HMODULE module = ::LoadLibrary("IMAGEHLP.DLL");
-    if (!module) return PR_FALSE;
-
-    _SymInitialize = (SYMINITIALIZEPROC) ::GetProcAddress(module, "SymInitialize");
-    if (!_SymInitialize) return PR_FALSE;
-
-    _SymCleanup = (SYMCLEANUPPROC)GetProcAddress(module, "SymCleanup");
-    if (!_SymCleanup) return PR_FALSE;
-
-    _StackWalk = (STACKWALKPROC)GetProcAddress(module, "StackWalk");
-    if (!_StackWalk) return PR_FALSE;
-
-    _SymFunctionTableAccess = (SYMFUNCTIONTABLEACCESSPROC) GetProcAddress(module, "SymFunctionTableAccess");
-    if (!_SymFunctionTableAccess) return PR_FALSE;
-
-    _SymGetModuleBase = (SYMGETMODULEBASEPROC)GetProcAddress(module, "SymGetModuleBase");
-    if (!_SymGetModuleBase) return PR_FALSE;
-
-    _SymGetSymFromAddr = (SYMGETSYMFROMADDRPROC)GetProcAddress(module, "SymGetSymFromAddr");
-    if (!_SymGetSymFromAddr) return PR_FALSE;
-
-    gInitialized = _SymInitialize(GetCurrentProcess(), 0, TRUE);
-  }
-
-  return gInitialized;
-}
-
-/**
- * Walk the stack, translating PC's found into strings and recording the
- * chain in aBuffer. For this to work properly, the dll's must be rebased
- * so that the address in the file agrees with the address in memory.
- * Otherwise StackWalk will return FALSE when it hits a frame in a dll's
- * whose in memory address doesn't match it's in-file address.
- *
- * Fortunately, there is a handy dandy routine in IMAGEHLP.DLL that does
- * the rebasing and accordingly I've made a tool to use it to rebase the
- * DLL's in one fell swoop (see xpcom/tools/windows/rebasedlls.cpp).
- */
-void
-nsTraceRefcnt::WalkTheStack(char* aBuffer, int aBufLen)
-{
-  aBuffer[0] = '\0';
-  aBufLen--;                    // leave room for nul
-
-  HANDLE myProcess = ::GetCurrentProcess();
-  HANDLE myThread = ::GetCurrentThread();
-
-  BOOL ok;
-
-  ok = EnsureSymInitialized();
-  if (! ok)
-    return;
-
-  // Get the context information for this thread. That way we will
-  // know where our sp, fp, pc, etc. are and can fill in the
-  // STACKFRAME with the initial values.
-  CONTEXT context;
-  context.ContextFlags = CONTEXT_FULL;
-  ok = GetThreadContext(myThread, &context);
-  if (! ok)
-    return;
-
-  // Setup initial stack frame to walk from
-  STACKFRAME frame;
-  memset(&frame, 0, sizeof(frame));
-  frame.AddrPC.Offset    = context.Eip;
-  frame.AddrPC.Mode      = AddrModeFlat;
-  frame.AddrStack.Offset = context.Esp;
-  frame.AddrStack.Mode   = AddrModeFlat;
-  frame.AddrFrame.Offset = context.Ebp;
-  frame.AddrFrame.Mode   = AddrModeFlat;
-
-  // Now walk the stack and map the pc's to symbol names that we stuff
-  // append to *cp.
-  char* cp = aBuffer;
-
-  int skip = 2;
-  while (aBufLen > 0) {
-    ok = _StackWalk(IMAGE_FILE_MACHINE_I386,
-                   myProcess,
-                   myThread,
-                   &frame,
-                   &context,
-                   0,                        // read process memory routine
-                   _SymFunctionTableAccess,  // function table access routine
-                   _SymGetModuleBase,        // module base routine
-                   0);                       // translate address routine
-
-    if (!ok || frame.AddrPC.Offset == 0)
-      break;
-
-    if (skip-- > 0)
-      continue;
-
-    char buf[sizeof(IMAGEHLP_SYMBOL) + 512];
-    PIMAGEHLP_SYMBOL symbol = (PIMAGEHLP_SYMBOL) buf;
-    symbol->SizeOfStruct = sizeof(buf);
-    symbol->MaxNameLength = 512;
-
-    DWORD displacement;
-    ok = _SymGetSymFromAddr(myProcess,
-                            frame.AddrPC.Offset,
-                            &displacement,
-                            symbol);
-
-    if (ok) {
-      int nameLen = strlen(symbol->Name);
-      if (nameLen + 12 > aBufLen) { // 12 == strlen("+0x12345678 ")
-        break;
-      }
-      char* cp2 = symbol->Name;
-      while (*cp2) {
-        if (*cp2 == ' ') *cp2 = '_'; // replace spaces with underscores
-        *cp++ = *cp2++;
-      }
-      aBufLen -= nameLen;
-      *cp++ = '+';
-      *cp++ = '0';
-      *cp++ = 'x';
-      PRInt32 len = nsIToA16(displacement, cp);
-      cp += len;
-      *cp++ = ' ';
-
-      aBufLen -= nameLen + len + 4;
-    }
-    else {
-      if (11 > aBufLen) { // 11 == strlen("0x12345678 ")
-        break;
-      }
-      *cp++ = '0';
-      *cp++ = 'x';
-      PRInt32 len = nsIToA16(frame.AddrPC.Offset, cp);
-      cp += len;
-      *cp++ = ' ';
-      aBufLen -= len + 3;
-    }
-  }
-  *cp = 0;
-}
-/* _WIN32 */
-
-
-#elif defined(linux) && defined(__GLIBC__) && defined(__i386) // i386 Linux stackwalking code
-
-void
-nsTraceRefcnt::WalkTheStack(char* aBuffer, int aBufLen)
-{
-  aBuffer[0] = '\0';
-  aBufLen--; // leave room for nul
-
-  char* cp = aBuffer;
-
-  jmp_buf jb;
-  setjmp(jb);
-
-  // Stack walking code courtesy Kipp's "leaky". 
-  u_long* bp = (u_long*) (jb[0].__jmpbuf[JB_BP]);
-  int skip = 2;
-  for (;;) {
-    u_long* nextbp = (u_long*) *bp++;
-    u_long pc = *bp;
-    if ((pc < 0x08000000) || (pc > 0x7fffffff) || (nextbp < bp)) {
-      break;
-    }
-    if (--skip <= 0) {
-      Dl_info info;
-      int ok = dladdr((void*) pc, &info);
-      if (ok < 0)
-        break;
-
-      int len = strlen(info.dli_sname);
-      if (! len)
-        break; // XXX Lazy. We could look at the filename or something.
-
-      if (len + 12 >= aBufLen) // 12 == strlen("+0x12345678 ")
-        break;
-
-      strcpy(cp, info.dli_sname);
-      cp += len;
-
-      *cp++ = '+';
-      *cp++ = '0';
-      *cp++ = 'x';
-
-      PRUint32 off = (char*)pc - (char*)info.dli_saddr;
-      PRInt32 addrStrLen = nsIToA16(off, cp);
-      cp += addrStrLen;
-
-      *cp++ = ' ';
-
-      aBufLen -= addrStrLen + 4;
-    }
-    bp = nextbp;
-  }
-  *cp = '\0';
-}
-
-#else // unsupported platform.
-
-NS_COM void
-nsTraceRefcnt::WalkTheStack(char* aBuffer, int aBufLen)
-{
-  // Write me!!!
-  *aBuffer = '\0';
-}
-
-#endif
-
-NS_COM void
-nsTraceRefcnt::LoadLibrarySymbols(const char* aLibraryName,
-                                  void* aLibrayHandle)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#if defined(_WIN32)
-  InitTraceLog();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    HANDLE myProcess = ::GetCurrentProcess();
-
-    if (!SymInitialize(myProcess, ".;..\\lib", TRUE)) {
-      return;
-    }
-
-    BOOL b = ::SymLoadModule(myProcess,
-                             NULL,
-                             (char*)aLibraryName,
-                             (char*)aLibraryName,
-                             0,
-                             0);
-//  DWORD lastError = 0;
-//  if (!b) lastError = ::GetLastError();
-//  printf("loading symbols for library %s => %s [%d]\n", aLibraryName,
-//         b ? "true" : "false", lastError);
-  }
-#endif
-#endif
-}
-
-NS_COM unsigned long
-nsTraceRefcnt::AddRef(void* aPtr,
-                      unsigned long aNewRefcnt,
-                      const char* aFile,
-                      PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("AddRef: %p: %d=>%d [%s] in %s (line %d)",
-            aPtr, aNewRefcnt-1, aNewRefcnt, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-  return aNewRefcnt;
-
-}
-
-NS_COM unsigned long
-nsTraceRefcnt::Release(void* aPtr,
-                       unsigned long aNewRefcnt,
-                       const char* aFile,
-                       PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("Release: %p: %d=>%d [%s] in %s (line %d)",
-            aPtr, aNewRefcnt+1, aNewRefcnt, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-  return aNewRefcnt;
-}
-
-NS_COM void
-nsTraceRefcnt::Create(void* aPtr,
-                      const char* aType,
-                      const char* aFile,
-                      PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("Create: %p[%s]: [%s] in %s (line %d)",
-            aPtr, aType, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-}
-
-NS_COM void
-nsTraceRefcnt::Destroy(void* aPtr,
-                      const char* aFile,
-                      PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("Destroy: %p: [%s] in %s (line %d)",
-            aPtr, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-}
-
-
-NS_COM void
-nsTraceRefcnt::LogAddRef(void* aPtr,
-                         nsrefcnt aRefCnt,
-                         const char* aFile,
-                         int aLine)
-{
-  InitTraceLog();
-  if (PR_LOG_TEST(gTraceRefcntLog, PR_LOG_DEBUG)) {
-    char sb[16384];
-    WalkTheStack(sb, sizeof(sb));
-    // Can't use PR_LOG(), b/c it truncates the line
-    printf("%s(%d) %p AddRef %d %s\n", aFile, aLine, aPtr, aRefCnt, sb);
-  }
-}
-
-
-NS_COM void
-nsTraceRefcnt::LogRelease(void* aPtr,
-                         nsrefcnt aRefCnt,
-                         const char* aFile,
-                         int aLine)
-{
-  InitTraceLog();
-  if (PR_LOG_TEST(gTraceRefcntLog, PR_LOG_DEBUG)) {
-    char sb[16384];
-    WalkTheStack(sb, sizeof(sb));
-    // Can't use PR_LOG(), b/c it truncates the line
-    printf("%s(%d) %p Release %d %s\n", aFile, aLine, aPtr, aRefCnt, sb);
-  }
-}

mozilla/xpcom/base/nsTraceRefcnt.h

@@ -1,72 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License.  You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#ifndef nsTraceRefcnt_h___
-#define nsTraceRefcnt_h___
-
-#include "nsCom.h"
-
-/**
- * This class is used to support tracing (and logging using nspr) of
- * addref and release calls. Note that only calls that use the
- * NS_ADDREF and related macros in nsISupports can be traced.
- *
- * The name of the nspr log module is "xpcomrefcnt" (case matters).
- *
- * This code only performs tracing built with debugging AND when
- * built with -DMOZ_TRACE_XPCOM_REFCNT (because it's expensive!).
- */
-class nsTraceRefcnt {
-public:
-  static NS_COM unsigned long AddRef(void* aPtr,
-                                     unsigned long aNewRefcnt,
-                                     const char* aFile,
-                                     int aLine);
-
-  static NS_COM unsigned long Release(void* aPtr,
-                                      unsigned long aNewRefcnt,
-                                      const char* aFile,
-                                      int aLine);
-
-  static NS_COM void Create(void* aPtr,
-                            const char* aType,
-                            const char* aFile,
-                            int aLine);
-
-  static NS_COM void Destroy(void* aPtr,
-                             const char* aFile,
-                             int aLine);
-
-  static NS_COM void LoadLibrarySymbols(const char* aLibraryName,
-                                        void* aLibrayHandle);
-
-  static NS_COM void WalkTheStack(char* aBuffer, int aBufLen);
-
-  static NS_COM void LogAddRef(void* aPtr,
-                               nsrefcnt aRefCnt,
-                               const char* aFile,
-                               int aLine);
-
-  static NS_COM void LogRelease(void* aPtr,
-                                nsrefcnt aRefCnt,
-                                const char* aFile,
-                                int aLine);
-
-};
-
-#endif /* nsTraceRefcnt_h___ */

mozilla/xpcom/base/nsTraceRefcntImpl.cpp

@@ -1,486 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License.  You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#include "nsISupports.h"
-#include "prprf.h"
-#include "prlog.h"
-
-#if defined(_WIN32)
-#include <windows.h>
-#elif defined(linux) && defined(__GLIBC__) && defined(__i386)
-#include <setjmp.h>
-
-//
-// On glibc 2.1, the Dl_info api defined in <dlfcn.h> is only exposed
-// if __USE_GNU is defined.  I suppose its some kind of standards
-// adherence thing.
-//
-#if (__GLIBC_MINOR__ >= 1)
-#define __USE_GNU
-#endif
-
-#include <dlfcn.h>
-
-#endif
-
-#if defined(NS_MT_SUPPORTED)
-#include "prlock.h"
-
-static PRLock* gTraceLock;
-
-#define LOCK_TRACELOG()   PR_Lock(gTraceLock)
-#define UNLOCK_TRACELOG() PR_Unlock(gTraceLock)
-#else /* ! NT_MT_SUPPORTED */
-#define LOCK_TRACELOG()
-#define UNLOCK_TRACELOG()
-#endif /* ! NS_MT_SUPPORTED */
-
-static PRLogModuleInfo* gTraceRefcntLog;
-
-static void InitTraceLog(void)
-{
-  if (0 == gTraceRefcntLog) {
-    gTraceRefcntLog = PR_NewLogModule("xpcomrefcnt");
-
-#if defined(NS_MT_SUPPORTED)
-    gTraceLock = PR_NewLock();
-#endif /* NS_MT_SUPPORTED */
-  }
-}
-
-
-int nsIToA16(PRUint32 aNumber, char* aBuffer)
-{
-  static char kHex[] = "0123456789abcdef";
-
-  if (aNumber == 0) {
-    *aBuffer = '0';
-    return 1;
-  }
-
-  char buf[8];
-  PRInt32 count = 0;
-  while (aNumber != 0) {
-    PRUint32 nibble = aNumber & 0xf;
-    buf[count++] = kHex[nibble];
-    aNumber >>= 4;
-  }
-
-  for (PRInt32 i = count - 1; i >= 0; --i)
-    *aBuffer++ = buf[i];
-
-  return count;
-}
-
-#if defined(_WIN32) // WIN32 stack walking code
-#include "imagehlp.h"
-#include <stdio.h>
-
-// Define these as static pointers so that we can load the DLL on the
-// fly (and not introduce a link-time dependency on it). Tip o' the
-// hat to Matt Pietrick for this idea. See:
-//
-//   http://msdn.microsoft.com/library/periodic/period97/F1/D3/S245C6.htm
-//
-typedef BOOL (__stdcall *SYMINITIALIZEPROC)(HANDLE, LPSTR, BOOL);
-static SYMINITIALIZEPROC _SymInitialize;
-
-typedef BOOL (__stdcall *SYMCLEANUPPROC)(HANDLE);
-static SYMCLEANUPPROC _SymCleanup;
-
-typedef BOOL (__stdcall *STACKWALKPROC)(DWORD,
-                                        HANDLE,
-                                        HANDLE,
-                                        LPSTACKFRAME,
-                                        LPVOID,
-                                        PREAD_PROCESS_MEMORY_ROUTINE,
-                                        PFUNCTION_TABLE_ACCESS_ROUTINE,
-                                        PGET_MODULE_BASE_ROUTINE,
-                                        PTRANSLATE_ADDRESS_ROUTINE);
-static STACKWALKPROC _StackWalk;
-
-typedef LPVOID (__stdcall *SYMFUNCTIONTABLEACCESSPROC)(HANDLE, DWORD);
-static SYMFUNCTIONTABLEACCESSPROC _SymFunctionTableAccess;
-
-typedef DWORD (__stdcall *SYMGETMODULEBASEPROC)(HANDLE, DWORD);
-static SYMGETMODULEBASEPROC _SymGetModuleBase;
-
-typedef BOOL (__stdcall *SYMGETSYMFROMADDRPROC)(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
-static SYMGETSYMFROMADDRPROC _SymGetSymFromAddr;
-
-
-static PRBool
-EnsureSymInitialized()
-{
-  PRBool gInitialized = PR_FALSE;
-
-  if (! gInitialized) {
-    HMODULE module = ::LoadLibrary("IMAGEHLP.DLL");
-    if (!module) return PR_FALSE;
-
-    _SymInitialize = (SYMINITIALIZEPROC) ::GetProcAddress(module, "SymInitialize");
-    if (!_SymInitialize) return PR_FALSE;
-
-    _SymCleanup = (SYMCLEANUPPROC)GetProcAddress(module, "SymCleanup");
-    if (!_SymCleanup) return PR_FALSE;
-
-    _StackWalk = (STACKWALKPROC)GetProcAddress(module, "StackWalk");
-    if (!_StackWalk) return PR_FALSE;
-
-    _SymFunctionTableAccess = (SYMFUNCTIONTABLEACCESSPROC) GetProcAddress(module, "SymFunctionTableAccess");
-    if (!_SymFunctionTableAccess) return PR_FALSE;
-
-    _SymGetModuleBase = (SYMGETMODULEBASEPROC)GetProcAddress(module, "SymGetModuleBase");
-    if (!_SymGetModuleBase) return PR_FALSE;
-
-    _SymGetSymFromAddr = (SYMGETSYMFROMADDRPROC)GetProcAddress(module, "SymGetSymFromAddr");
-    if (!_SymGetSymFromAddr) return PR_FALSE;
-
-    gInitialized = _SymInitialize(GetCurrentProcess(), 0, TRUE);
-  }
-
-  return gInitialized;
-}
-
-/**
- * Walk the stack, translating PC's found into strings and recording the
- * chain in aBuffer. For this to work properly, the dll's must be rebased
- * so that the address in the file agrees with the address in memory.
- * Otherwise StackWalk will return FALSE when it hits a frame in a dll's
- * whose in memory address doesn't match it's in-file address.
- *
- * Fortunately, there is a handy dandy routine in IMAGEHLP.DLL that does
- * the rebasing and accordingly I've made a tool to use it to rebase the
- * DLL's in one fell swoop (see xpcom/tools/windows/rebasedlls.cpp).
- */
-void
-nsTraceRefcnt::WalkTheStack(char* aBuffer, int aBufLen)
-{
-  aBuffer[0] = '\0';
-  aBufLen--;                    // leave room for nul
-
-  HANDLE myProcess = ::GetCurrentProcess();
-  HANDLE myThread = ::GetCurrentThread();
-
-  BOOL ok;
-
-  ok = EnsureSymInitialized();
-  if (! ok)
-    return;
-
-  // Get the context information for this thread. That way we will
-  // know where our sp, fp, pc, etc. are and can fill in the
-  // STACKFRAME with the initial values.
-  CONTEXT context;
-  context.ContextFlags = CONTEXT_FULL;
-  ok = GetThreadContext(myThread, &context);
-  if (! ok)
-    return;
-
-  // Setup initial stack frame to walk from
-  STACKFRAME frame;
-  memset(&frame, 0, sizeof(frame));
-  frame.AddrPC.Offset    = context.Eip;
-  frame.AddrPC.Mode      = AddrModeFlat;
-  frame.AddrStack.Offset = context.Esp;
-  frame.AddrStack.Mode   = AddrModeFlat;
-  frame.AddrFrame.Offset = context.Ebp;
-  frame.AddrFrame.Mode   = AddrModeFlat;
-
-  // Now walk the stack and map the pc's to symbol names that we stuff
-  // append to *cp.
-  char* cp = aBuffer;
-
-  int skip = 2;
-  while (aBufLen > 0) {
-    ok = _StackWalk(IMAGE_FILE_MACHINE_I386,
-                   myProcess,
-                   myThread,
-                   &frame,
-                   &context,
-                   0,                        // read process memory routine
-                   _SymFunctionTableAccess,  // function table access routine
-                   _SymGetModuleBase,        // module base routine
-                   0);                       // translate address routine
-
-    if (!ok || frame.AddrPC.Offset == 0)
-      break;
-
-    if (skip-- > 0)
-      continue;
-
-    char buf[sizeof(IMAGEHLP_SYMBOL) + 512];
-    PIMAGEHLP_SYMBOL symbol = (PIMAGEHLP_SYMBOL) buf;
-    symbol->SizeOfStruct = sizeof(buf);
-    symbol->MaxNameLength = 512;
-
-    DWORD displacement;
-    ok = _SymGetSymFromAddr(myProcess,
-                            frame.AddrPC.Offset,
-                            &displacement,
-                            symbol);
-
-    if (ok) {
-      int nameLen = strlen(symbol->Name);
-      if (nameLen + 12 > aBufLen) { // 12 == strlen("+0x12345678 ")
-        break;
-      }
-      char* cp2 = symbol->Name;
-      while (*cp2) {
-        if (*cp2 == ' ') *cp2 = '_'; // replace spaces with underscores
-        *cp++ = *cp2++;
-      }
-      aBufLen -= nameLen;
-      *cp++ = '+';
-      *cp++ = '0';
-      *cp++ = 'x';
-      PRInt32 len = nsIToA16(displacement, cp);
-      cp += len;
-      *cp++ = ' ';
-
-      aBufLen -= nameLen + len + 4;
-    }
-    else {
-      if (11 > aBufLen) { // 11 == strlen("0x12345678 ")
-        break;
-      }
-      *cp++ = '0';
-      *cp++ = 'x';
-      PRInt32 len = nsIToA16(frame.AddrPC.Offset, cp);
-      cp += len;
-      *cp++ = ' ';
-      aBufLen -= len + 3;
-    }
-  }
-  *cp = 0;
-}
-/* _WIN32 */
-
-
-#elif defined(linux) && defined(__GLIBC__) && defined(__i386) // i386 Linux stackwalking code
-
-void
-nsTraceRefcnt::WalkTheStack(char* aBuffer, int aBufLen)
-{
-  aBuffer[0] = '\0';
-  aBufLen--; // leave room for nul
-
-  char* cp = aBuffer;
-
-  jmp_buf jb;
-  setjmp(jb);
-
-  // Stack walking code courtesy Kipp's "leaky". 
-  u_long* bp = (u_long*) (jb[0].__jmpbuf[JB_BP]);
-  int skip = 2;
-  for (;;) {
-    u_long* nextbp = (u_long*) *bp++;
-    u_long pc = *bp;
-    if ((pc < 0x08000000) || (pc > 0x7fffffff) || (nextbp < bp)) {
-      break;
-    }
-    if (--skip <= 0) {
-      Dl_info info;
-      int ok = dladdr((void*) pc, &info);
-      if (ok < 0)
-        break;
-
-      int len = strlen(info.dli_sname);
-      if (! len)
-        break; // XXX Lazy. We could look at the filename or something.
-
-      if (len + 12 >= aBufLen) // 12 == strlen("+0x12345678 ")
-        break;
-
-      strcpy(cp, info.dli_sname);
-      cp += len;
-
-      *cp++ = '+';
-      *cp++ = '0';
-      *cp++ = 'x';
-
-      PRUint32 off = (char*)pc - (char*)info.dli_saddr;
-      PRInt32 addrStrLen = nsIToA16(off, cp);
-      cp += addrStrLen;
-
-      *cp++ = ' ';
-
-      aBufLen -= addrStrLen + 4;
-    }
-    bp = nextbp;
-  }
-  *cp = '\0';
-}
-
-#else // unsupported platform.
-
-NS_COM void
-nsTraceRefcnt::WalkTheStack(char* aBuffer, int aBufLen)
-{
-  // Write me!!!
-  *aBuffer = '\0';
-}
-
-#endif
-
-NS_COM void
-nsTraceRefcnt::LoadLibrarySymbols(const char* aLibraryName,
-                                  void* aLibrayHandle)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-#if defined(_WIN32)
-  InitTraceLog();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    HANDLE myProcess = ::GetCurrentProcess();
-
-    if (!SymInitialize(myProcess, ".;..\\lib", TRUE)) {
-      return;
-    }
-
-    BOOL b = ::SymLoadModule(myProcess,
-                             NULL,
-                             (char*)aLibraryName,
-                             (char*)aLibraryName,
-                             0,
-                             0);
-//  DWORD lastError = 0;
-//  if (!b) lastError = ::GetLastError();
-//  printf("loading symbols for library %s => %s [%d]\n", aLibraryName,
-//         b ? "true" : "false", lastError);
-  }
-#endif
-#endif
-}
-
-NS_COM unsigned long
-nsTraceRefcnt::AddRef(void* aPtr,
-                      unsigned long aNewRefcnt,
-                      const char* aFile,
-                      PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("AddRef: %p: %d=>%d [%s] in %s (line %d)",
-            aPtr, aNewRefcnt-1, aNewRefcnt, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-  return aNewRefcnt;
-
-}
-
-NS_COM unsigned long
-nsTraceRefcnt::Release(void* aPtr,
-                       unsigned long aNewRefcnt,
-                       const char* aFile,
-                       PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("Release: %p: %d=>%d [%s] in %s (line %d)",
-            aPtr, aNewRefcnt+1, aNewRefcnt, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-  return aNewRefcnt;
-}
-
-NS_COM void
-nsTraceRefcnt::Create(void* aPtr,
-                      const char* aType,
-                      const char* aFile,
-                      PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("Create: %p[%s]: [%s] in %s (line %d)",
-            aPtr, aType, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-}
-
-NS_COM void
-nsTraceRefcnt::Destroy(void* aPtr,
-                      const char* aFile,
-                      PRIntn aLine)
-{
-#ifdef MOZ_TRACE_XPCOM_REFCNT
-  InitTraceLog();
-
-  LOCK_TRACELOG();
-  if (PR_LOG_TEST(gTraceRefcntLog,PR_LOG_DEBUG)) {
-    char sb[1000];
-    WalkTheStack(sb, sizeof(sb));
-    PR_LOG(gTraceRefcntLog, PR_LOG_DEBUG,
-           ("Destroy: %p: [%s] in %s (line %d)",
-            aPtr, sb, aFile, aLine));
-  }
-  UNLOCK_TRACELOG();
-#endif
-}
-
-
-NS_COM void
-nsTraceRefcnt::LogAddRef(void* aPtr,
-                         nsrefcnt aRefCnt,
-                         const char* aFile,
-                         int aLine)
-{
-  InitTraceLog();
-  if (PR_LOG_TEST(gTraceRefcntLog, PR_LOG_DEBUG)) {
-    char sb[16384];
-    WalkTheStack(sb, sizeof(sb));
-    // Can't use PR_LOG(), b/c it truncates the line
-    printf("%s(%d) %p AddRef %d %s\n", aFile, aLine, aPtr, aRefCnt, sb);
-  }
-}
-
-
-NS_COM void
-nsTraceRefcnt::LogRelease(void* aPtr,
-                         nsrefcnt aRefCnt,
-                         const char* aFile,
-                         int aLine)
-{
-  InitTraceLog();
-  if (PR_LOG_TEST(gTraceRefcntLog, PR_LOG_DEBUG)) {
-    char sb[16384];
-    WalkTheStack(sb, sizeof(sb));
-    // Can't use PR_LOG(), b/c it truncates the line
-    printf("%s(%d) %p Release %d %s\n", aFile, aLine, aPtr, aRefCnt, sb);
-  }
-}

mozilla/xpcom/base/nsTraceRefcntImpl.h

@@ -1,72 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License.  You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-#ifndef nsTraceRefcnt_h___
-#define nsTraceRefcnt_h___
-
-#include "nsCom.h"
-
-/**
- * This class is used to support tracing (and logging using nspr) of
- * addref and release calls. Note that only calls that use the
- * NS_ADDREF and related macros in nsISupports can be traced.
- *
- * The name of the nspr log module is "xpcomrefcnt" (case matters).
- *
- * This code only performs tracing built with debugging AND when
- * built with -DMOZ_TRACE_XPCOM_REFCNT (because it's expensive!).
- */
-class nsTraceRefcnt {
-public:
-  static NS_COM unsigned long AddRef(void* aPtr,
-                                     unsigned long aNewRefcnt,
-                                     const char* aFile,
-                                     int aLine);
-
-  static NS_COM unsigned long Release(void* aPtr,
-                                      unsigned long aNewRefcnt,
-                                      const char* aFile,
-                                      int aLine);
-
-  static NS_COM void Create(void* aPtr,
-                            const char* aType,
-                            const char* aFile,
-                            int aLine);
-
-  static NS_COM void Destroy(void* aPtr,
-                             const char* aFile,
-                             int aLine);
-
-  static NS_COM void LoadLibrarySymbols(const char* aLibraryName,
-                                        void* aLibrayHandle);
-
-  static NS_COM void WalkTheStack(char* aBuffer, int aBufLen);
-
-  static NS_COM void LogAddRef(void* aPtr,
-                               nsrefcnt aRefCnt,
-                               const char* aFile,
-                               int aLine);
-
-  static NS_COM void LogRelease(void* aPtr,
-                                nsrefcnt aRefCnt,
-                                const char* aFile,
-                                int aLine);
-
-};
-
-#endif /* nsTraceRefcnt_h___ */

mozilla/xpcom/base/nscore.h

@@ -1,164 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#ifndef nscore_h___
-#define nscore_h___
-
-#ifdef _WIN32
-#define NS_WIN32 1
-#endif
-
-#if defined(__unix)
-#define NS_UNIX 1
-#endif
-
-#include "prtypes.h"
-
-#ifdef __cplusplus
-#include "nsDebug.h"
-#endif
-
-#ifndef __PRUNICHAR__
-#define __PRUNICHAR__
-typedef PRUint16 PRUnichar;
-#endif
-
-/* The preferred symbol for null. */
-#define nsnull 0
-
-/* Define brackets for protecting C code from C++ */
-#ifdef __cplusplus
-#define NS_BEGIN_EXTERN_C extern "C" {
-#define NS_END_EXTERN_C }
-#else
-#define NS_BEGIN_EXTERN_C
-#define NS_END_EXTERN_C
-#endif
-
-/*----------------------------------------------------------------------*/
-/* Import/export defines */
-
-#ifdef NS_WIN32
-#define NS_IMPORT _declspec(dllimport)
-#define NS_IMPORT_(type) type _declspec(dllimport) __stdcall
-#define NS_EXPORT _declspec(dllexport)
-/* XXX NS_EXPORT_ defined in nsCOm.h (xpcom) differs in where the __declspec
-   is placed. It needs to be done this way to make the 4.x compiler happy... */
-#undef NS_EXPORT_
-#define NS_EXPORT_(type) type _declspec(dllexport) __stdcall
-#elif defined(XP_MAC)
-
-#define NS_IMPORT
-#define NS_IMPORT_(type) type
-
-/* XXX NS_EXPORT_ defined in nsCom.h actually does an export. Here it's just sugar. */
-#undef NS_EXPORT
-#undef NS_EXPORT_
-
-#define NS_EXPORT __declspec(export)
-#define NS_EXPORT_(type) __declspec(export) type
-
-#else
-/* XXX do something useful? */
-#define NS_IMPORT
-#define NS_IMPORT_(type) type
-#define NS_EXPORT
-#define NS_EXPORT_(type) type
-#endif
-
-#ifdef _IMPL_NS_BASE
-#define NS_BASE NS_EXPORT
-#else
-#define NS_BASE NS_IMPORT
-#endif
-
-#ifdef _IMPL_NS_NET
-#define NS_NET NS_EXPORT
-#else
-#define NS_NET NS_IMPORT
-#endif
-
-#ifdef _IMPL_NS_DOM
-#define NS_DOM NS_EXPORT
-#else
-#define NS_DOM NS_IMPORT
-#endif
-
-#ifdef _IMPL_NS_WIDGET
-#define NS_WIDGET NS_EXPORT
-#else
-#define NS_WIDGET NS_IMPORT
-#endif
-
-#ifdef _IMPL_NS_VIEW
-#define NS_VIEW NS_EXPORT
-#else
-#define NS_VIEW NS_IMPORT
-#endif
-
-#ifdef _IMPL_NS_GFXNONXP
-#define NS_GFXNONXP NS_EXPORT
-#define NS_GFXNONXP_(type) NS_EXPORT_(type)
-#else
-#define NS_GFXNONXP NS_IMPORT
-#define NS_GFXNONXP_(type) NS_IMPORT_(type)
-#endif
-
-#ifdef _IMPL_NS_GFX
-#define NS_GFX NS_EXPORT
-#define NS_GFX_(type) NS_EXPORT_(type)
-#else
-#define NS_GFX NS_IMPORT
-#define NS_GFX_(type) NS_IMPORT_(type)
-#endif
-
-#ifdef _IMPL_NS_PLUGIN
-#define NS_PLUGIN NS_EXPORT
-#else
-#define NS_PLUGIN NS_IMPORT
-#endif
-
-#ifdef _IMPL_NS_APPSHELL
-#define NS_APPSHELL NS_EXPORT
-#else
-#define NS_APPSHELL NS_IMPORT
-#endif
-
-
-/* ------------------------------------------------------------------------ */
-/* Casting macros for hiding C++ features from older compilers */
-
-/* unix now determines this automatically */
-#ifndef XP_UNIX
-#define HAVE_CPP_NEW_CASTS /* we'll be optimistic. */
-#endif
-
-#if defined(HAVE_CPP_NEW_CASTS)
-#define NS_STATIC_CAST(__type, __ptr)      static_cast<__type>(__ptr)
-#define NS_CONST_CAST(__type, __ptr)       const_cast<__type>(__ptr)
-#define NS_REINTERPRET_CAST(__type, __ptr) reinterpret_cast<__type>(__ptr)
-#else
-#define NS_STATIC_CAST(__type, __ptr)      ((__type)(__ptr))
-#define NS_CONST_CAST(__type, __ptr)       ((__type)(__ptr))
-#define NS_REINTERPRET_CAST(__type, __ptr) ((__type)(__ptr))
-#endif
-
-/* No sense in making an NS_DYNAMIC_CAST() macro: you can't duplicate
-   the semantics. So if you want to dynamic_cast, then just use it
-   "straight", no macro. */
-
-#endif /* nscore_h___ */

mozilla/xpcom/base/nsrootidl.idl

@@ -1,63 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-/* Root idl declarations to be used by all. */
-
-%{C++
-
-#include "nscore.h"
-#include "prtime.h"
-
-/* 
- * Start commenting out the C++ versions of the below in the output header
- */
-#if 0
-%}
-
-typedef boolean             PRBool   ;
-typedef octet               PRUint8  ;
-typedef unsigned short      PRUint16 ;
-typedef unsigned long       PRUint32 ;
-typedef unsigned long long  PRUint64 ;
-typedef unsigned long long  PRTime   ;
-typedef short               PRInt16  ;
-typedef long                PRInt32  ;
-typedef long long           PRInt64  ;
-
-typedef unsigned long       nsrefcnt ;
-typedef unsigned long       nsresult ;
-
-[ptr]         native voidStar(void);
-[ptr]         native charStar(char);
-
-[ref, nsid]   native nsIDRef(nsID);
-[ref, nsid]   native nsIIDRef(nsIID);
-[ref, nsid]   native nsCIDRef(nsCID);
-
-[ptr, nsid]   native nsIDPtr(nsID);
-[ptr, nsid]   native nsIIDPtr(nsIID);
-[ptr, nsid]   native nsCIDPtr(nsCID);
-
-[ptr]         native nsQIResult(void);
-
-%{C++
-/* 
- * End commenting out the C++ versions of the above in the output header
- */
-#endif
-%}

mozilla/xpcom/build/Makefile.in

@@ -1,84 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-#
-
-DEPTH		= ../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME	= xpcom
-MODULE		= xpcom
-
-CPPSRCS		= nsXPComInit.cpp
-
-REQUIRES	= xpcom
-
-include $(topsrcdir)/config/config.mk
-
-LOCAL_INCLUDES	+= \
-		-I$(srcdir)/../base \
-		-I$(srcdir)/../ds \
-		-I$(srcdir)/../io \
-		-I$(srcdir)/../components \
-		-I$(srcdir)/../threads \
-		-I$(srcdir)/../proxy/src \
-		$(NULL)
-
-DEFINES		+= -D_IMPL_NS_COM -D_IMPL_NS_BASE
-
-SHARED_LIBRARY_LIBS = \
-		$(DIST)/lib/libxpcomds_s.a \
-		$(DIST)/lib/libxpcomio_s.a \
-		$(DIST)/lib/libxpcomcomponents_s.a \
-		$(DIST)/lib/libxpcomthreads_s.a \
-		$(DIST)/lib/libxpcomproxy_s.a \
-		$(DIST)/lib/libxpcombase_s.a \
-		$(DIST)/lib/libxptcall.a \
-		$(DIST)/lib/libxptinfo.a \
-		$(DIST)/lib/libxpt.a \
-		$(DIST)/lib/libxptcmd.a \
-		$(DIST)/lib/libreg.a \
-		$(NULL)
-
-ifeq ($(OS_ARCH),HP-UX)
-EXTRA_DSO_LDOPTS = -c objs/objslist
-else
-EXTRA_DSO_LDOPTS = \
-	$(MKSHLIB_FORCE_ALL) \
-	$(SHARED_LIBRARY_LIBS) \
-	$(MKSHLIB_UNFORCE_ALL)
-endif
-
-ifeq ($(OS_ARCH),BeOS)
-EXTRA_DSO_LDOPTS += -lbe
-endif
-
-include $(topsrcdir)/config/rules.mk
-
-ifeq ($(OS_ARCH),HP-UX)
-shared_library_objs: $(SHARED_LIBRARY_LIBS)
-	rm -rf objs
-	mkdir objs
-	(cd objs; for lib in $(SHARED_LIBRARY_LIBS); do ar xv ../$$lib; done) \
-	| awk '{ print "objs/"$$3 }' > objs/objslist
-
-$(LIBRARY) $(SHARED_LIBRARY): shared_library_objs Makefile
-else
-$(LIBRARY) $(SHARED_LIBRARY): $(SHARED_LIBRARY_LIBS) Makefile
-endif

mozilla/xpcom/build/dlldeps.cpp

@@ -1,83 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-// Force references to all of the symbols that we want exported from
-// the dll that are located in the .lib files we link with
-
-#include "nsVoidArray.h"
-#include "nsIAtom.h"
-#include "nsFileSpec.h"
-#include "nsIBuffer.h"
-//#include "nsIByteBufferInputStream.h"
-#include "nsFileStream.h"
-#include "nsFileSpecStreaming.h"
-#include "nsSpecialSystemDirectory.h"
-#include "nsIThread.h"
-#include "nsDeque.h"
-#include "nsObserver.h"
-#include "nsTraceRefcnt.h"
-#include "nsXPIDLString.h"
-#include "nsIEnumerator.h"
-#include "nsEnumeratorUtils.h"
-#include "nsQuickSort.h"
-#include "nsString2.h"
-#include "nsProxyEventPrivate.h"
-#include "xpt_xdr.h"
-#include "nsInterfaceInfo.h"
-#include "xptcall.h"
-#include "nsIFileSpec.h"
-#include "nsIGenericFactory.h"
-
-
-void XXXNeverCalled()
-{
-    nsVoidArray();
-    NS_GetNumberOfAtoms();
-    nsFileURL(NULL);
-    NS_NewPipe(NULL, NULL, 0, 0, 0, NULL);
-    nsFileSpec s;
-    NS_NewIOFileStream(NULL, s, 0, 0);
-    nsInputFileStream(s, 0, 0);
-    nsPersistentFileDescriptor d;
-    ReadDescriptor(NULL, d);
-    new nsSpecialSystemDirectory(nsSpecialSystemDirectory::OS_DriveDirectory);
-    nsIThread::GetCurrent(NULL);
-    nsDeque(NULL);
-    NS_NewObserver(NULL, NULL);
-    nsTraceRefcnt::AddRef(NULL, 0, NULL, 0);
-    nsXPIDLCString::Copy(NULL);
-    NS_NewEmptyEnumerator(NULL);
-    nsArrayEnumerator(NULL);
-    NS_NewIntersectionEnumerator(NULL, NULL, NULL);
-    NS_QuickSort(NULL, 0, 0, NULL, NULL);
-    nsString2();
-    nsProxyObject();
-    XPT_DoString(NULL, NULL);
-    XPT_DoHeader(NULL, NULL);
-    nsInterfaceInfo* info = NULL;
-    info->GetName(NULL);
-#ifdef DEBUG
-    info->print(NULL);
-#endif
-    XPTC_InvokeByIndex(NULL, 0, 0, NULL);
-    NS_NewFileSpec(NULL);
-    xptc_dummy();
-    xptc_dummy2();
-    XPTI_GetInterfaceInfoManager();
-    NS_NewGenericFactory(NULL, NULL, NULL);
-}

mozilla/xpcom/build/makefile.win

@@ -1,86 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-IGNORE_MANIFEST=1
-
-DEPTH=..\..
-MODULE = xpcom 
-
-LIBNAME = .\$(OBJDIR)\xpcom
-DLL = $(LIBNAME).dll
-
-LINCS =                          \
-	-I$(PUBLIC)\xpcom        \
-        -I..\base                \
-        -I..\ds                  \
-        -I..\io                  \
-        -I..\components          \
-        -I..\threads             \
-        -I..\reflect\xptinfo\src \
-        -I..\proxy\src           \
-	$(NULL)
-
-LCFLAGS=-D_IMPL_NS_COM        \
-        -D_IMPL_NS_BASE       \
-        -DWIN32_LEAN_AND_MEAN \
-        -DEXPORT_XPT_API      \
-        -DEXPORT_XPTC_API     \
-        -DEXPORT_XPTI_API
-
-CPP_OBJS =                             \
-        .\$(OBJDIR)\nsXPComInit.obj    \
-        .\$(OBJDIR)\dlldeps.obj        \
-        $(NULL)
-
-!ifndef BUILD_OPT
-#CPP_OBJS = $(CPP_OBJS) .\$(OBJDIR)\nsConstructorPattern.obj
-!endif
-
-OURLIBS =                              \
-	$(LIBNSPR)                     \
-	$(DIST)\lib\plc3.lib           \
-        $(DIST)\lib\xpcombase_s.lib    \
-        $(DIST)\lib\xpcomds_s.lib      \
-        $(DIST)\lib\xpcomio_s.lib      \
-        $(DIST)\lib\xpcomcomp_s.lib    \
-        $(DIST)\lib\xpcomthreads_s.lib \
-        $(DIST)\lib\xpcomxpt_s.lib     \
-	$(DIST)\lib\xpcomxptcall_s.lib \
-	$(DIST)\lib\xpcomxptcmd_s.lib  \
-        $(DIST)\lib\xpcomxptinfo_s.lib \
-        $(DIST)\lib\xpcomproxy_s.lib   \
-	$(DIST)\lib\libreg32.lib       \
-	$(NULL)
-
-LLIBS =                                \
-        $(OURLIBS)                     \
-        shell32.lib                    \
-!if "$(MOZ_BITS)"=="32" && defined(MOZ_DEBUG) && defined(GLOWCODE)
-	$(GLOWDIR)\glowcode.lib        \
-!endif
-!if defined(MOZ_TRACE_XPCOM_REFCNT)
-	imagehlp.lib                   \
-!endif	
-	$(NULL)
-
-MISCDEP=$(OURLIBS)
-
-include <$(DEPTH)\config\rules.mak>
-
-libs:: $(DLL)
-	$(MAKE_INSTALL) $(LIBNAME).$(DLL_SUFFIX) $(DIST)\bin
-	$(MAKE_INSTALL) $(LIBNAME).$(LIB_SUFFIX) $(DIST)\lib

mozilla/xpcom/build/nsConstructorPattern.cpp

@@ -1,243 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL. You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation. Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All Rights
- * Reserved.
- */
-
-#include "nsISupports.h"
-
-////////////////////////////////////////////////////////////////////////////////
-// nsIFoo.h
-////////////////////////////////////////////////////////////////////////////////
-// Here's an interface that we're going to work with. Normally it would be
-// defined in nsIFoo.h:
-
-#define NS_IFOO_IID                                  \
-{ /* f981ba10-1547-11d3-9337-00104ba0fd40 */         \
-    0xf981ba10,                                      \
-    0x1547,                                          \
-    0x11d3,                                          \
-    {0x93, 0x37, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
-}
-
-#define NS_FOO_CID                                   \
-{ /* fe1a5870-1547-11d3-9337-00104ba0fd40 */         \
-    0xfe1a5870,                                      \
-    0x1547,                                          \
-    0x11d3,                                          \
-    {0x93, 0x37, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
-}
-
-class nsIFoo : public nsISupports {
-public:
-    NS_DEFINE_STATIC_IID_ACCESSOR(NS_IFOO_IID);
-
-    NS_IMETHOD Init(const char* name) = 0;
-    NS_IMETHOD Doit(int x) = 0;
-};
-
-// Define a global constructor function if you really need one. Otherwise
-// you can always use nsIComponentManager::CreateInstance.
-PR_EXTERN(nsresult)
-NS_NewFoo(nsIFoo* *result, const char* name);
-
-////////////////////////////////////////////////////////////////////////////////
-// nsFoo.h
-////////////////////////////////////////////////////////////////////////////////
-// Here's the implementation class definition. Put this in an nsFoo.h (and don't
-// export it to dist).
-
-//#include "nsIFoo.h"
-
-class nsFoo : public nsIFoo {
-public:
-    // Define the constructor, but don't give it arguments that are needed
-    // for initialization that can fail:
-    nsFoo();
-    // Always make the destructor virtual: 
-    virtual ~nsFoo();
-
-    // Define a Create method to be used with a factory:
-    static NS_METHOD
-    Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult);
-    
-    // from nsIFoo:
-    NS_IMETHOD Init(const char* name);
-
-    NS_IMETHOD Doit(int x);
-
-    // from nsISupports:
-    NS_DECL_ISUPPORTS
-
-protected:
-    // instance variables:
-    char* mName;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// nsFoo.cpp
-////////////////////////////////////////////////////////////////////////////////
-// Here's the implementation. Put this in an nsFoo.cpp.
-
-//#include "nsFoo.h"
-#include "nsCRT.h"
-#include <stdio.h>
-
-// Don't do anything in the constructor that can fail. Just initialize all 
-// the instance variables and get out:
-nsFoo::nsFoo()
-    : mName(NULL)
-{
-    NS_INIT_REFCNT();
-}
-
-// Do anything that can fail in the Init method. It's a good idea to provide
-// one so that in the future if someone adds something that can fail they'll
-// be encouraged to do it right:
-NS_IMETHODIMP
-nsFoo::Init(const char* name)
-{
-    mName = nsCRT::strdup(name);
-    if (mName == NULL)
-        return NS_ERROR_OUT_OF_MEMORY;
-    return NS_OK;
-}
-
-// Destroy and release things as usual in the destructor:
-nsFoo::~nsFoo()
-{
-    if (mName)
-        nsCRT::free(mName);
-}
-
-// Provide a Create method that can be called by a factory constructor:
-NS_METHOD
-nsFoo::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult)
-{
-    if (aOuter)
-        return NS_ERROR_NO_AGGREGATION;
-  
-    nsFoo* foo = new nsFoo();
-    if (foo == NULL)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    // Note that Create doesn't initialize the instance -- that has to
-    // be done by the caller since the initialization args aren't passed
-    // in here.
-
-    // AddRef before calling QI -- this makes it easier to handle the QI
-    // failure case because we'll always just Release and return
-    NS_ADDREF(foo);
-    nsresult rv = foo->QueryInterface(aIID, aResult);
-
-    // This will free it if QI failed:
-    NS_RELEASE(foo);
-    return rv;
-}
-
-// Implement the nsISupports methods:
-NS_IMPL_ISUPPORTS(nsFoo, nsIFoo::GetIID());
-
-// Implement the method(s) of the interface:
-NS_IMETHODIMP
-nsFoo::Doit(int x)
-{
-    printf("%s %d\n", mName, x);
-    return NS_OK;
-}
-
-// Finally, (if you really need one) implement a global constructor function
-// for this class:
-PR_IMPLEMENT(nsresult)
-NS_NewFoo(nsIFoo* *result, const char* name)
-{
-    // Use the constructor method to create this. Don't duplicate work.
-    nsresult rv = nsFoo::Create(NULL, nsIFoo::GetIID(),
-                                (void**)result);
-    if (NS_SUCCEEDED(rv)) {
-        // Only initialize if the constructor succeeded:
-        rv = (*result)->Init(name);
-    }
-    return rv;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsFooModuleFactory.cpp
-////////////////////////////////////////////////////////////////////////////////
-// This file defines the factory that instantiates nsFoo and any other classes
-// in the same component. It also defines the component's NSGetFactory, 
-// NSRegisterSelf and NSUnregisterSelf entry points:
-
-// Include nsFoo.h to get the nsFoo::Create method:
-//#include "nsFoo.h"
-
-#include "nsIComponentManager.h"
-#include "nsIServiceManager.h"
-
-// Include the generic factory stuff. It's the easiest and smallest way to 
-// work with factories:
-#include "nsGenericFactory.h"
-
-static NS_DEFINE_CID(kFooCID, NS_FOO_CID);
-static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
-
-extern "C" PR_IMPLEMENT(nsresult)
-NSGetFactory(nsISupports* aServMgr,
-             const nsCID &aClass,
-             const char *aClassName,
-             const char *aProgID,
-             nsIFactory **aFactory)
-{
-    nsresult rv;
-    nsIGenericFactory* fact;
-    if (aClass.Equals(kFooCID))
-        rv = NS_NewGenericFactory(&fact, nsFoo::Create);
-    else 
-        rv = NS_ERROR_FAILURE;
-
-    if (NS_SUCCEEDED(rv))
-        *aFactory = fact;
-    return rv;
-}
-
-extern "C" PR_IMPLEMENT(nsresult)
-NSRegisterSelf(nsISupports* aServMgr , const char* aPath)
-{
-    nsresult rv;
-
-    NS_WITH_SERVICE1(nsIComponentManager, compMgr,
-                     aServMgr, kComponentManagerCID, &rv);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = compMgr->RegisterComponent(kFooCID, "Foo", NULL,
-                                    aPath, PR_TRUE, PR_TRUE);
-
-    return rv;
-}
-
-extern "C" PR_IMPLEMENT(nsresult)
-NSUnregisterSelf(nsISupports* aServMgr, const char* aPath)
-{
-    nsresult rv;
-    NS_WITH_SERVICE1(nsIComponentManager, compMgr,
-                     aServMgr, kComponentManagerCID, &rv);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = compMgr->UnregisterComponent(kFooCID, aPath);
-
-    return rv;
-}
-
-////////////////////////////////////////////////////////////////////////////////

mozilla/xpcom/build/nsXPComInit.cpp

@@ -1,263 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL. You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation. Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation. All Rights
- * Reserved.
- */
-
-#include "nsIRegistry.h"
-#include "nscore.h"
-#include "nsCOMPtr.h"
-#include "nsObserverService.h"
-#include "nsObserver.h"
-#include "nsProperties.h"
-
-#include "nsAllocator.h"
-#include "nsArena.h"
-#include "nsBuffer.h"
-#include "nsByteBuffer.h"
-#include "nsPageMgr.h"
-#include "nsSupportsArray.h"
-#include "nsUnicharBuffer.h"
-
-#include "nsComponentManager.h"
-#include "nsIServiceManager.h"
-#include "nsGenericFactory.h"
-
-#include "nsEventQueueService.h"
-#include "nsEventQueue.h"
-
-#include "nsProxyObjectManager.h"
-#include "nsProxyEventPrivate.h"  // access to the impl of nsProxyObjectManager for the generic factory registration.
-
-#include "nsFileSpecImpl.h"
-
-// base
-static NS_DEFINE_CID(kAllocatorCID, NS_ALLOCATOR_CID);
-// ds
-static NS_DEFINE_CID(kArenaCID, NS_ARENA_CID);
-static NS_DEFINE_CID(kBufferCID, NS_BUFFER_CID);
-static NS_DEFINE_CID(kByteBufferCID, NS_BYTEBUFFER_CID);
-static NS_DEFINE_CID(kPageManagerCID, NS_PAGEMANAGER_CID);
-static NS_DEFINE_CID(kPropertiesCID, NS_PROPERTIES_CID);
-static NS_DEFINE_CID(kSupportsArrayCID, NS_SUPPORTSARRAY_CID);
-static NS_DEFINE_CID(kUnicharBufferCID, NS_UNICHARBUFFER_CID);
-// io
-static NS_DEFINE_CID(kFileSpecCID, NS_FILESPEC_CID);
-static NS_DEFINE_CID(kDirectoryIteratorCID, NS_DIRECTORYITERATOR_CID);
-// components
-static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
-static NS_DEFINE_CID(kGenericFactoryCID, NS_GENERICFACTORY_CID);
-// threads
-static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
-static NS_DEFINE_CID(kEventQueueCID, NS_EVENTQUEUE_CID);
-// proxy
-static NS_DEFINE_CID(kProxyObjectManagerCID, NS_PROXYEVENT_MANAGER_CID);
-
-////////////////////////////////////////////////////////////////////////////////
-// XPCOM initialization
-//
-// To Control the order of initialization of these key components I am putting
-// this function.
-//
-//	- nsServiceManager
-//		- nsComponentManager
-//			- nsRegistry
-//
-// Here are key points to remember:
-//	- A global of all these need to exist. nsServiceManager is an independent object.
-//	  nsComponentManager uses both the globalServiceManager and its own registry.
-//
-//	- A static object of both the nsComponentManager and nsServiceManager
-//	  are in use. Hence InitXPCOM() gets triggered from both
-//	  NS_GetGlobale{Service/Component}Manager() calls.
-//
-//	- There exists no global Registry. Registry can be created from the component manager.
-//
-
-static nsresult
-RegisterGenericFactory(nsIComponentManager* compMgr, const nsCID& cid, const char* className,
-                       const char *progid, nsIGenericFactory::ConstructorProcPtr constr)
-{
-    nsresult rv;
-    nsIGenericFactory* fact;
-    rv = NS_NewGenericFactory(&fact, constr);
-    if (NS_FAILED(rv)) return rv;
-    rv = compMgr->RegisterFactory(cid, className, progid, fact, PR_TRUE);
-    NS_RELEASE(fact);
-    return rv;
-}
-
-nsIServiceManager* nsServiceManager::mGlobalServiceManager = NULL;
-nsComponentManagerImpl* nsComponentManagerImpl::gComponentManager = NULL;
-
-nsresult NS_InitXPCOM(nsIServiceManager* *result)
-{
-    nsresult rv = NS_OK;
-
-    // 1. Create the Global Service Manager
-    nsIServiceManager* servMgr = NULL;
-    if (nsServiceManager::mGlobalServiceManager == NULL)
-    {
-        rv = NS_NewServiceManager(&servMgr);
-        if (NS_FAILED(rv)) return rv;
-        nsServiceManager::mGlobalServiceManager = servMgr;
-        if (result)
-		{
-	        NS_ADDREF(servMgr);
-			*result = servMgr;
-		}
-    }
-
-    // 2. Create the Component Manager and register with global service manager
-    //    It is understood that the component manager can use the global service manager.
-    nsComponentManagerImpl *compMgr = NULL;
-    if (nsComponentManagerImpl::gComponentManager == NULL)
-    {
-        compMgr = new nsComponentManagerImpl();
-        if (compMgr == NULL)
-            return NS_ERROR_OUT_OF_MEMORY;
-        NS_ADDREF(compMgr);
-        rv = compMgr->Init();
-        if (NS_FAILED(rv))
-        {
-            NS_RELEASE(compMgr);
-            return rv;
-        }
-        nsComponentManagerImpl::gComponentManager = compMgr;
-    }
-    
-    rv = servMgr->RegisterService(kComponentManagerCID, compMgr);
-    if (NS_FAILED(rv)) return rv;
-
-    // 3. Register the global services with the component manager so that
-    //    clients can create new objects.
-
-    // Registry
-    nsIFactory *registryFactory = NULL;
-    rv = NS_RegistryGetFactory(&registryFactory);
-    if (NS_FAILED(rv)) return rv;
-
-    NS_DEFINE_CID(kRegistryCID, NS_REGISTRY_CID);
-
-    rv = compMgr->RegisterFactory(kRegistryCID,
-                                  NS_REGISTRY_CLASSNAME,
-                                  NS_REGISTRY_PROGID,
-                                  registryFactory, PR_TRUE);
-    NS_RELEASE(registryFactory);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kAllocatorCID,
-                                NS_ALLOCATOR_CLASSNAME,
-                                NS_ALLOCATOR_PROGID,
-                                nsAllocatorImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kArenaCID,
-                                NS_ARENA_CLASSNAME,
-                                NS_ARENA_PROGID,
-                                ArenaImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kBufferCID,
-                                NS_BUFFER_CLASSNAME,
-                                NS_BUFFER_PROGID,
-                                nsBuffer::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kByteBufferCID,
-                                NS_BYTEBUFFER_CLASSNAME,
-                                NS_BYTEBUFFER_PROGID,
-                                ByteBufferImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kFileSpecCID,
-                                NS_FILESPEC_CLASSNAME,
-                                NS_FILESPEC_PROGID,
-                                nsFileSpecImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kDirectoryIteratorCID,
-                                NS_DIRECTORYITERATOR_CLASSNAME,
-                                NS_DIRECTORYITERATOR_PROGID,
-                                nsDirectoryIteratorImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kPageManagerCID,
-                                NS_PAGEMANAGER_CLASSNAME,
-                                NS_PAGEMANAGER_PROGID,
-                                nsPageMgr::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kPropertiesCID,
-                                NS_PROPERTIES_CLASSNAME,
-                                NS_PROPERTIES_PROGID,
-                                nsProperties::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kPersistentPropertiesCID,
-                                NS_PERSISTENTPROPERTIES_CLASSNAME,
-                                NS_PERSISTENTPROPERTIES_PROGID,
-                                nsPersistentProperties::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kSupportsArrayCID,
-                                NS_SUPPORTSARRAY_CLASSNAME,
-                                NS_SUPPORTSARRAY_PROGID,
-                                nsSupportsArray::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, nsObserver::GetCID(), 
-                                NS_OBSERVER_CLASSNAME,
-                                NS_OBSERVER_PROGID,
-                                nsObserver::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, nsObserverService::GetCID(),
-                                NS_OBSERVERSERVICE_CLASSNAME,
-                                NS_OBSERVERSERVICE_PROGID,
-                                nsObserverService::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kGenericFactoryCID,
-                                NS_GENERICFACTORY_CLASSNAME,
-                                NS_GENERICFACTORY_PROGID,
-                                nsGenericFactory::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kEventQueueServiceCID,
-                                NS_EVENTQUEUESERVICE_CLASSNAME,
-                                NS_EVENTQUEUESERVICE_PROGID,
-                                nsEventQueueServiceImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, kEventQueueCID,
-                                NS_EVENTQUEUE_CLASSNAME,
-                                NS_EVENTQUEUE_PROGID,
-                                nsEventQueueImpl::Create);
-    if (NS_FAILED(rv)) return rv;
-
-    rv = RegisterGenericFactory(compMgr, 
-                                kProxyObjectManagerCID, 
-                                NS_XPCOMPROXY_CLASSNAME,
-                                NS_XPCOMPROXY_PROGID,
-                                nsProxyObjectManager::Create);
-
-    // Prepopulate registry for performance
-    nsComponentManagerImpl::gComponentManager->PlatformPrePopulateRegistry();
-
-    return rv;
-}
-
-////////////////////////////////////////////////////////////////////////////////

mozilla/xpcom/components/MANIFEST

@@ -1,8 +0,0 @@
-nsIComponentManager.h
-nsIFactory.h
-nsIGenericFactory.h
-nsIRegistry.h
-nsIServiceManager.h
-nsIServiceProvider.h
-nsRepository.h
-nsXPComFactory.h

mozilla/xpcom/components/Makefile.in

@@ -1,72 +0,0 @@
-#!gmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-DEPTH=../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-include $(topsrcdir)/config/config.mk
-
-LIBRARY_NAME = xpcomcomponents_s
-
-MODULE = xpcom
-
-XPIDLSRCS =               \
-	$(NULL)
-
-CPPSRCS =				\
-        nsComponentManager.cpp \
-        nsGenericFactory.cpp   \
-        nsRegistry.cpp         \
-        nsRepository.cpp       \
-        nsServiceManager.cpp   \
-        xcDll.cpp              \
-	$(NULL)
-
-EXPORTS = \
-        nsIComponentManager.h \
-        nsIFactory.h          \
-        nsIGenericFactory.h   \
-        nsIRegistry.h         \
-        nsIServiceManager.h   \
-        nsIServiceProvider.h  \
-        nsRepository.h        \
-        nsXPComFactory.h      \
-	$(NULL)
-
-EXPORTS := $(addprefix $(srcdir)/, $(EXPORTS))
-
-DEFINES += -DUSE_NSREG -D_IMPL_NS_COM -D_IMPL_NS_BASE
-
-REQUIRES = xpcom libreg
-
-LOCAL_INCLUDES += 		\
-	-I$(srcdir)/../base	\
-	-I$(srcdir)/../thread	\
-	$(NULL)
-
-MKSHLIB :=
-
-# we don't want the shared lib, but we want to force the creation of a static lib.
-override NO_SHARED_LIB=1
-override NO_STATIC_LIB=
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/xpcom/components/makefile.win

@@ -1,69 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-IGNORE_MANIFEST=1
-
-DEPTH=..\..
-MODULE = xpcom 
-
-################################################################################
-## exports
-
-EXPORTS =                     \
-        nsIComponentManager.h \
-        nsIFactory.h          \
-        nsIGenericFactory.h   \
-        nsIRegistry.h         \
-        nsIServiceManager.h   \
-        nsIServiceProvider.h  \
-        nsRepository.h        \
-        nsXPComFactory.h      \
-        $(NULL)			
-
-XPIDLSRCS =               \
-        $(NULL)
-
-################################################################################
-## library
-
-LIBRARY_NAME=xpcomcomp_s
-
-LINCS =                    \
-	-I$(PUBLIC)\xpcom  \
-	-I$(PUBLIC)\libreg \
-        -I..\base          \
-        -I..\threads       \
-	$(NULL)
-
-LCFLAGS = -DUSE_NSREG -D_IMPL_NS_COM -D_IMPL_NS_BASE -DWIN32_LEAN_AND_MEAN
-
-CPP_OBJS =                                 \
-        .\$(OBJDIR)\nsComponentManager.obj \
-        .\$(OBJDIR)\nsGenericFactory.obj   \
-        .\$(OBJDIR)\nsRegistry.obj         \
-        .\$(OBJDIR)\nsRepository.obj       \
-        .\$(OBJDIR)\nsServiceManager.obj   \
-        .\$(OBJDIR)\xcDll.obj              \
-        $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-libs:: $(LIBRARY)
-	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-clobber::
-        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib

mozilla/xpcom/components/mozIClassRegistry.h

@@ -1,168 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#ifndef __mozIClassRegistry_h
-#define __mozIClassRegistry_h
-
-#include "nsIComponentManager.h"
-
-/*---------------------------- mozIClassRegistry -------------------------------
-| This interface provides access to a mapping from mnemonic interface names    |
-| to shared libraries where implementations of those interfaces can be located.|
-|                                                                              |
-| This interface is designed to provide two things:                            |
-|   1. A means of less static binding between clients and the code that        |
-|      implements the XPCOM interfaces those clients use.  This accomplished   |
-|      by the mapping from interface names to nsCID (and the shared libraries  |
-|      that implement those classes).                                          |
-|   2. A means of dynamically changing the mapping from interface name to      |
-|      implementation.  The canonical example of this is to switch to a        |
-|      "native" widget set versus an "XP" (implemented using gfx) set.         |
-|                                                                              |
-| The first goal is achieved by storing (in a "Netscape Registry" file, see    |
-| nsReg.h) information that maps interface/class "names" to information about  |
-| where to load implementations of those interfaces.  That information         |
-| includes the interface ID, class ID (of the implementation class), and the   |
-| name of the shared library that contains the implementation.                 |
-|                                                                              |
-| The class registry object will register those classes with the "repository"  |
-| (see nsComponentManager.h) the first time a request is made to create an           |
-| instance.  Subsequent requests will simply be forwarded to the repository    |
-| after the appropriate interface and class IDs are determined.                |
-|                                                                              |
-| The second goal is accomplished by permitting the mnemonic interface         |
-| "names" to be "overloaded", that is, mapped to distinct implementations      |
-| by separate class registry objects.  Further, class registries can be        |
-| cascaded: they can be chained together so that when a name is not            |
-| recognized by one registry, it can pass the request to the next registry in  |
-| the chain.  Users can control resolution by making the request of a          |
-| registry further up/down the chain.                                          |
-|                                                                              |
-| For example, consider the case of "native" vs. "gfx" widgets.  This might    |
-| be structured by a class registry arrangment like this:                      |
-|                                                                              |
-|      nativeWidgetRegistry          baseWidgetRegistry                        |
-|          +----------+                 +----------+                           |
-|          |      ----+---------------->|          |                           |
-|          +----------+                 +----------+                           |
-|          |toolbar| -+-----+           |toolbar| -+-----+                     |
-|          +----------+     |           +----------+     |                     |
-|          |button | -+-----+           |button | -+-----+                     |
-|          +----------+     |           +----------+     |                     |
-|                           V                            V                     |
-|                  +-----------------+          +-----------------+            |
-|                  |   native.dll    |          |    base.dll     |            |
-|                  +-----------------+          +-----------------+            |
-|                                                                              |
-|  If a specialized implementation of widgets is present (e.g., native.dll)    |
-|  then a corresponding class registry object is created and added to the      |
-|  head of the registry chain.  Object creation requests (normal ones) are     |
-|  resolved to the native implementation.  If such a library is not present,   |
-|  then the resolution is to the base implementation.  If objects of the       |
-|  base implementation are required, then creation requests can be directed    |
-|  directly to the baseWidgetRegistry object, rather than the head of the      |
-|  registry chain.                                                             |
-|                                                                              |
-|  It is intended that there be a single instance of this interface, accessed  |
-|  via the Service Manager (see nsServiceManager.h).                           |
-------------------------------------------------------------------------------*/
-struct mozIClassRegistry : public ISupports {
-
-    /*------------------------------ CreateInstance ----------------------------
-    | Create an instance of the requested class/interface.  The interface      |
-    | ID is required to specify how the result will be treated.  The class     |
-    | named by aName must support this interface.  The result is placed in     |
-    | ncomment aResult (NULL if the request fails).  "start" specifies the     |
-    | registry at which the search for an implementation of the named          |
-    | interface should start.  It defaults to 0 (indicating to start at the    |
-    | head of the registry chain).                                             |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD CreateInstance( const char *anInterfaceName,
-                               const nsIID &aIID,
-                               void*      *aResult,
-                               const char *start = 0 ) = 0;
-
-    /*--------------------------- CreateEnumerator -----------------------------
-    | Creates an nsIEnumerator interface object that can be used to examine    |
-    | the contents of the registry.  "pattern" specifies either "*" or the     |
-    | name of a specific interface that you want to query.  "result" will      |
-    | be set to point to a new object (which will be freed on the last call    |
-    | to its Release() member).  See nsIEnumerator.h for details on how to     |                                          
-    | use the returned interface pointer.                                      |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD CreateEnumerator( const char     *pattern,
-                                 nsIEnumerator* *result ) = 0;
-}; // mozIClassRegistry
-
-
-/*-------------------------- mozIClassRegistryEntry ----------------------------
-| Objects of this class represent the individual elements that comprise a      |
-| mozIClassRegistry interface.  You obtain such objects by applying the        |
-| CreateEnumerator member function to the class registry and then applying     |
-| the CurrentItem member function to the resulting nsIEnumerator interface.    |
-|                                                                              |
-| Each entry can be queried for the following information:                     |
-|   o sub-registry name                                                        |
-|   o interface name                                                           |
-|   o Class ID                                                                 |
-|   o IIDs implemented                                                         |
-|                                                                              |
-| The information obtained from the entry (specifically, the const char*       |
-| strings) remains valid for the life of the entry (i.e., until you            |
-| Release() it).                                                               |
-|                                                                              |
-| Here is an example of code that uses this interface to dump the contents     |
-| of a mozIClassRegistry:                                                      |
-|                                                                              |
-|    mozIClassRegistry *reg = nsServiceManager::GetService( kIDRegistry );     |
-|    nsIEnumerator *enum;                                                      |
-|    reg->CreateEnumerator( "*", &enum );                                      |
-|    for ( enum->First(); !enum->IsDone(); enum->Next(); ) {                   |
-|       mozIClassRegistryEntry *entry;                                         |
-|       enum->CurrentItem( &entry );                                           |
-|       const char *subreg;                                                    |
-|       const char *name;                                                      |
-|       nsCID cid;                                                             |
-|       int   numIIDs;                                                         |
-|       entry->GetSubRegistryName( &subreg );                                  |
-|       entry->GetInterfaceName( &name );                                      |
-|       entry->GetClassID( &cid );                                             |
-|       entry->GetNumIIDs( &numIIDs );                                         |
-|       cout << subreg << "/" << name << " = " << cid.ToString() << endl;      |
-|       for ( int i = 0; i < numIIDs; i++ ) {                                  |
-|           nsIID iid;                                                         |
-|           entry->GetInterfaceID( i, &iid );                                  |
-|           cout << "/tIID[" << i << "] = " << iid.ToString() << endl;         |
-|       }                                                                      |
-|       entry->Release();                                                      |
-|    }                                                                         |
-|    enum->Release();                                                          |
-------------------------------------------------------------------------------*/
-struct mozIClassRegistryEntry : public nsISupports {
-    NS_IMETHOD GetSubRegistryName( const char **result ) = 0;
-    NS_IMETHOD GetInterfaceName( const char **result ) = 0;
-    NS_IMETHOD GetClassID( nsCID *result ) = 0;
-    NS_IMETHOD GetNumIIDs( int *result ) = 0;
-    NS_IMETHOD GetInterfaceID( int n, nsIID *result ) = 0;
-}; // mozIClassRegistryEntry
-
-// {5D41A440-8E37-11d2-8059-00600811A9C3}
-#define MOZ_ICLASSREGISTRY_IID { 0x5d41a440, 0x8e37, 0x11d2, { 0x80, 0x59, 0x0, 0x60, 0x8, 0x11, 0xa9, 0xc3 } }
-// {D1B54831-AC07-11d2-805E-00600811A9C3}
-#define MOZ_ICLASSREGISTRYENTRY_IID { 0xd1b54831, 0xac07, 0x11d2, { 0x80, 0x5e, 0x0, 0x60, 0x8, 0x11, 0xa9, 0xc3 } }
-
-#endif

mozilla/xpcom/components/mozIRegistry.h

@@ -1,326 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#ifndef __mozIRegistry_h
-#define __mozIRegistry_h
-
-#include "nsISupports.h"
-
-class nsIEnumerator;
-
-/*------------------------------- mozIRegistry ---------------------------------
-| This interface provides access to a tree of arbitrary values.                |
-|                                                                              |
-| Each node of the tree contains either a value or a subtree or both.          |
-|                                                                              |
-| The value at any of these leaf nodes can be any of these "primitive" types:  |
-|   o string (null terminated UTF string)                                      |
-|   o array of 32-bit integers                                                 |
-|   o arbitrary array of bytes                                                 |
-|   o file identifier                                                          |
-| Of course, since you can store an arbitrary array of bytes, you can put      |
-| any data you like into a registry (although you have the burden of           |
-| encoding/decoding your data in that case).                                   |
-|                                                                              |
-| Each branch of the tree is labelled with a string "key."  The entire path    |
-| from a given point of the tree to another point further down can be          |
-| presented as a single string composed of each branch's label, concatenated   |
-| to the next, with an intervening forward slash ('/').  The term "key"        |
-| refers to both specific tree branch labels and to such concatenated paths.   |
-|                                                                              |
-| The branches from a given node must have unique labels.  Distinct nodes can  |
-| have branches with the same label.                                           |
-|                                                                              |
-| For example, here's a small registry tree:                                   |
-|                                            |                                 |
-|                                           /\                                 |
-|                                         /    \                               |
-|                                       /        \                             |
-|                                     /            \                           |
-|                              "Classes"          "Users"                      |
-|                                 /                  \                         |
-|                               /                      \                       |
-|                             /                      ["joe"]                   |
-|                           /                          / \                     |
-|                          |                          /   \                    |
-|                         /\                         /     \                   |
-|                       /    \                    "joe"   "bob"                |
-|                     /        \                    /       \                  |
-|                                                  /         \                 |
-|        "{xxxx-xx-1}"       "{xxxx-xx-2}"  ["c:/joe"]   ["d:/Robert"]         |
-|             |                    |                                           |
-|            /\                   /\                                           |
-|          /    \               /    \                                         |
-|        /        \           /        \                                       |
-|    "Library" "Version"  "Library" "Version"                                  |
-|       /         \          /          \                                      |
-| ["foo.dll"]      2   ["bar.dll"]       1                                     |
-|                                                                              |
-| In this example, there are 2 keys under the root: "Classes" and "Users".     |
-| The first denotes a subtree only (which has two subtrees, ...).  The second  |
-| denotes both a value ["joe"] and two subtrees labelled "joe" and "bob".      |
-| The value at the node "/Users" is ["joe"], at "/Users/bob" is ["d:/Robert"]. |
-| The value at "/Classes/{xxxx-xx-1}/Version" is 2.                            |
-|                                                                              |
-| The registry interface provides functions that let you navigate the tree     |
-| and manipulate it's contents.                                                |
-|                                                                              |
-| Please note that the registry itself does not impose any structure or        |
-| meaning on the contents of the tree.  For example, the registry doesn't      |
-| control whether the value at the key "/Users" is the label for the subtree   |
-| with information about the last active user.  That meaning is applied by     |
-| the code that stores these values and uses them for that purpose.            |
-|                                                                              |
-| [Any resemblence between this example and actual contents of any actual      |
-| registry is purely coincidental.]                                            |
-------------------------------------------------------------------------------*/
-struct mozIRegistry : public nsISupports {
-    /*------------------------------ Constants ---------------------------------
-    | The following enumerated types and values are used by the registry       |
-    | interface.                                                               |
-    --------------------------------------------------------------------------*/
-    typedef enum {
-        String = 1,
-        Int32,
-        Bytes,
-        File
-    } DataType;
-
-    /*-------------------------------- Types -----------------------------------
-    | The following data types are used by this interface.  All are basically  |
-    | opaque types.  You obtain objects of these types via certain member      |
-    | function calls and re-use them later (without having to know what they   |
-    | contain).                                                                |
-    |                                                                          |
-    |   Key       - Placeholder to represent a particular node in a registry   |
-    |               tree.  There are 3 enumerated values that correspond to    |
-    |               specific nodes:                                            |
-    |                   Common      - Where most stuff goes.                   |
-    |                   Users       - Special subtree to hold info about       |
-    |                                 "users"; if you don't know what goes     |
-    |                                 here, don't mess with it.                |
-    |                   CurrentUser - Subtree under Users corresponding to     |
-    |                                 whatever user is designed the "current"  |
-    |                                 one; see note above.                     |
-    |               You can specify any of these enumerated values as "keys"   |
-    |               on any member function that takes a mozRegistry::Key.      |
-    |   ValueInfo - Structure describing a registry value.                     |
-    --------------------------------------------------------------------------*/
-    typedef uint32 Key;
-
-    enum { Users = 1, Common = 2, CurrentUser = 3 };
-
-    struct ValueInfo {
-        DataType type;
-        uint32   length;
-    };
-
-    /*--------------------------- Opening/Closing ------------------------------
-    | These functions open the specified registry file (Open() with a non-null |
-    | argument) or the default "standard" registry file (Open() with a null    |
-    | argument or OpenDefault()).                                              |
-    |                                                                          |
-    | Once opened, you can access the registry contents via the read/write     |
-    | or query functions.                                                      |
-    |                                                                          |
-    | The registry file will be closed automatically when the registry object  |
-    | is destroyed.  You can close the file prior to that by using the         |
-    | Close() function.                                                        |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD Open( const char *regFile = 0 ) = 0;
-    NS_IMETHOD OpenDefault() = 0;
-    NS_IMETHOD Close() = 0;
-
-    /*----------------------- Reading/Writing Values ---------------------------
-    | These functions read/write the registry values at a given node.          |
-    |                                                                          |
-    | All functions require you to specify where in the registry key to        |
-    | get/set the value.  The location is specified using two components:      |
-    |   o A "base key" indicating where to start from; this is a value of type |
-    |     mozIRegistry::Key.  You use either one of the special "root" key     |
-    |     values or a subkey obtained via some other member function call.     |
-    |   o A "relative path," expressed as a sequence of subtree names          |
-    |     separated by forward slashes.  This path describes how to get from   |
-    |     the base key to the node at which you want to store the data.  This  |
-    |     component can be a null pointer which means the value goes directly  |
-    |     at the node denoted by the base key.                                 |
-    |                                                                          |
-    | When you request a value of a given type, the data stored at the         |
-    | specified node must be of the type requested.  If not, an error results. |
-    |                                                                          |
-    | GetString - Obtains a newly allocated copy of a string type value.  The  |
-    |             caller is obligated to free the returned string using        |
-    |             PR_Free.                                                     |
-    | SetString - Stores the argument string at the specified node.            |
-    | GetInt    - Obtains an int32 value at the specified node.  The result    |
-    |             is returned into an int32 location you specify.              |
-    | SetInt    - Stores a given int32 value at a node.                        |
-    | GetBytes  - Obtains a byte array value; this returns both an allocated   |
-    |             array of bytes and a length (necessary because there may be  |
-    |             embedded null bytes in the array).  You must free the        |
-    |             resulting array using PR_Free.                               |
-    | SetBytes  - Stores a given array of bytes; you specify the bytes via a   |
-    |             pointer and a length.                                        |
-    | GetIntArray - Obtains the array of int32 values stored at a given node.  |
-    |             The result is composed of two values: a pointer to an        |
-    |             array of integer values (which must be freed using           |
-    |             PR_Free) and the number of elements in that array.           |
-    | SetIntArray - Stores a set of int32 values at a given node.  You must    |
-    |             provide a pointer to the array and the number of entries.    |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD GetString( Key baseKey, const char *path, char **result ) = 0;
-    NS_IMETHOD SetString( Key baseKey, const char *path, const char *value ) = 0;
-    NS_IMETHOD GetInt( Key baseKey, const char *path, int32 *result ) = 0;
-    NS_IMETHOD SetInt( Key baseKey, const char *path, int32 value ) = 0;
-    NS_IMETHOD GetBytes( Key baseKey, const char *path, void **result, uint32 *len ) = 0;
-    NS_IMETHOD SetBytes( Key baseKey, const char *path, void *value, uint32 len ) = 0;
-    NS_IMETHOD GetIntArray( Key baseKey, const char *path, int32 **result, uint32 *len ) = 0;
-    NS_IMETHOD SetIntArray( Key baseKey, const char *path, const int32 *value, uint32 len ) = 0;
-
-    /*------------------------------ Navigation --------------------------------
-    | These functions let you navigate through the registry tree, querying     |
-    | its contents.                                                            |
-    |                                                                          |
-    | As above, all these functions requires a starting tree location ("base   |
-    | key")  specified as a mozIRegistry::Key.  Some also require a path       |
-    | name to locate the registry node location relative to this base key.     |
-    |                                                                          |
-    | AddSubtree           - Adds a new registry subtree at the specified      |
-    |                        location.  Returns the resulting key in           |
-    |                        the location specified by the third argument      |
-    |                        (unless that pointer is 0).                       |
-    | RemoveNode           - Removes the specified registry subtree or         |
-    |                        value at the specified location.                  |
-    | GetSubtree           - Returns a mozIRegistry::Key that can be used      |
-    |                        to refer to the specified registry location.      |
-    | EnumerateSubtrees    - Returns a nsIEnumerator object that you can       |
-    |                        use to enumerate all the subtrees descending      |
-    |                        from a specified location.  You must free the     |
-    |                        enumerator via Release() when you're done with    |
-    |                        it.                                               |
-    | EnumerateAllSubtrees - Like EnumerateSubtrees, but will recursively      |
-    |                        enumerate lower-level subtrees, too.              |
-    | GetValueInfo         - Returns a uint32 value that designates the type   |
-    |                        of data stored at this location in the registry;  |
-    |                        the possible values are defined by the enumerated |
-    |                        type mozIRegistry::DataType.                      |
-    | GetValueLength       - Returns a uint32 value that indicates the length  |
-    |                        of this registry value; the length is the number  |
-    |                        of characters (for Strings), the number of bytes  |
-    |                        (for Bytes), or the number of int32 values (for   |
-    |                        Int32).                                           |
-    | EnumerateValues      - Returns a nsIEnumerator that you can use to       |
-    |                        enumerate all the value nodes descending from     |
-    |                        a specified location.                             |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD AddSubtree( Key baseKey, const char *path, Key *result ) = 0;
-    NS_IMETHOD RemoveSubtree( Key baseKey, const char *path ) = 0;
-    NS_IMETHOD GetSubtree( Key baseKey, const char *path, Key *result ) = 0;
-
-    NS_IMETHOD EnumerateSubtrees( Key baseKey, nsIEnumerator **result ) = 0;
-    NS_IMETHOD EnumerateAllSubtrees( Key baseKey, nsIEnumerator **result ) = 0;
-
-    NS_IMETHOD GetValueType( Key baseKey, const char *path, uint32 *result ) = 0;
-    NS_IMETHOD GetValueLength( Key baseKey, const char *path, uint32 *result ) = 0;
-
-    NS_IMETHOD EnumerateValues( Key baseKey, nsIEnumerator **result ) = 0;
-
-    /*------------------------------ User Name ---------------------------------
-    | These functions manipulate the current "user name."  This value controls |
-    | the behavior of certain registry functions (namely, ?).                  |
-    |                                                                          |
-    | GetCurrentUserName allocates a copy of the current user name (which the  |
-    | caller should free using PR_Free).                                       |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD GetCurrentUserName( char **result ) = 0;
-    NS_IMETHOD SetCurrentUserName( const char *name ) = 0;
-
-    /*------------------------------ Utilities ---------------------------------
-    | Various utility functions:                                               |
-    |                                                                          |
-    | Pack() is used to compress the contents of an open registry file.        |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD Pack() = 0;
-
-}; // mozIRegistry
-
-/*----------------------------- mozIRegistryNode -------------------------------
-| This interface is implemented by all the objects obtained from the           |
-| nsIEnumerators that mozIRegistry provides when you call either of the        |
-| subtree enumeration functions EnumerateSubtrees or EnumerateAllSubtrees.     |
-|                                                                              |
-| You can call this function to get the name of this subtree.  This is the     |
-| relative path from the base key from which you got this interface.           |
-|                                                                              |
-|   GetName - Returns the path name of this node; this is the relative path    |
-|             from the base key from which this subtree was obtained.  The     |
-|             function allocates a copy of the name; the caller must free it   |
-|             using PR_Free.                                                   |
-------------------------------------------------------------------------------*/
-struct mozIRegistryNode : public nsISupports {
-    NS_IMETHOD GetName( char **result ) = 0;
-}; // mozIRegistryNode
-
-/*----------------------------- mozIRegistryValue ------------------------------
-| This interface is implemented by the objects obtained from the               |
-| nsIEnumerators that mozIRegistry provides when you call the                  |
-| EnumerateValues function.  An object supporting this interface is            |
-| returned when you call the CurrentItem() function on that enumerator.        |
-|                                                                              |
-| You use the member functions of this interface to obtain information         |
-| about each registry value.                                                   |
-|                                                                              |
-|   GetName      - Returns the path name of this node; this is the relative    |
-|                  path\ from the base key from which this value was obtained. |
-|                  The function allocates a copy of the name; the caller must  |
-|                  subsequently free it via PR_Free.                           |
-|   GetValueType - Returns (into a location provided by the caller) the type   |
-|                  of the value; the types are defined by the enumerated       |
-|                  type mozIRegistry::DataType.                                |
-|   GetValueLength - Returns a uint32 value that indicates the length          |
-|                    of this registry value; the length is the number          |
-|                    of characters (for Strings), the number of bytes          |
-|                    (for Bytes), or the number of int32 values (for           |
-|                    Int32).                                                   |
-------------------------------------------------------------------------------*/
-struct mozIRegistryValue : public nsISupports {
-    NS_IMETHOD GetName( char **result ) = 0;
-    NS_IMETHOD GetValueType( uint32 *result ) = 0;
-    NS_IMETHOD GetValueLength( uint32 *result ) = 0;
-}; // mozIRegistryEntry
-
-
-/*------------------------------- Error Codes ----------------------------------
-------------------------------------------------------------------------------*/
-#define NS_ERROR_REG_BADTYPE          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 1 )
-#define NS_ERROR_REG_NO_MORE          NS_ERROR_GENERATE_SUCCESS( NS_ERROR_MODULE_REG, 2 )
-#define NS_ERROR_REG_NOT_FOUND        NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 3 )
-#define NS_ERROR_REG_NOFILE	          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 4 )
-#define NS_ERROR_REG_BUFFER_TOO_SMALL NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 5 )
-#define NS_ERROR_REG_NAME_TOO_LONG    NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 6 )
-#define NS_ERROR_REG_NO_PATH          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 7 )
-#define NS_ERROR_REG_READ_ONLY        NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 8 )
-#define NS_ERROR_REG_BAD_UTF8         NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 9 )
-
-// {5D41A440-8E37-11d2-8059-00600811A9C3}
-#define MOZ_IREGISTRY_IID { 0x5d41a440, 0x8e37, 0x11d2, { 0x80, 0x59, 0x0, 0x60, 0x8, 0x11, 0xa9, 0xc3 } }
-// {D1B54831-AC07-11d2-805E-00600811A9C3}
-#define MOZ_IREGISTRYNODE_IID { 0xd1b54831, 0xac07, 0x11d2, { 0x80, 0x5e, 0x0, 0x60, 0x8, 0x11, 0xa9, 0xc3 } }
-// {5316C380-B2F8-11d2-A374-0080C6F80E4B}
-#define MOZ_IREGISTRYVALUE_IID { 0x5316c380, 0xb2f8, 0x11d2, { 0xa3, 0x74, 0x0, 0x80, 0xc6, 0xf8, 0xe, 0x4b } }
-
-#endif

mozilla/xpcom/components/nsComponentManager.h

@@ -1,260 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsComponentManager_h__
-#define nsComponentManager_h__
-
-#include "nsIComponentManager.h"
-#include "nsIRegistry.h"
-#include "nsHashtable.h"
-#include "prtime.h"
-#include "prmon.h"
-
-class nsFactoryEntry;
-class nsDll;
-
-// Registry Factory creation function defined in nsRegistry.cpp
-// We hook into this function locally to create and register the registry
-// Since noone outside xpcom needs to know about this and nsRegistry.cpp
-// does not have a local include file, we are putting this definition
-// here rather than in nsIRegistry.h
-extern "C" NS_EXPORT nsresult NS_RegistryGetFactory(nsIFactory** aFactory);
-
-////////////////////////////////////////////////////////////////////////////////
-
-class nsComponentManagerImpl : public nsIComponentManager {
-public:
-    NS_DECL_ISUPPORTS
-
-    // nsIComponentManager methods:
-    NS_IMETHOD FindFactory(const nsCID &aClass,
-                           nsIFactory **aFactory);
-
-    // Finds a class ID for a specific Program ID
-    NS_IMETHOD ProgIDToCLSID(const char *aProgID,
-                             nsCID *aClass);
-  
-    // Finds a Program ID for a specific class ID
-    // caller frees the result with delete[]
-    NS_IMETHOD CLSIDToProgID(nsCID *aClass,
-                             char* *aClassName,
-                             char* *aProgID);
-  
-    // Creates a class instance for a specific class ID
-    NS_IMETHOD CreateInstance(const nsCID &aClass, 
-                              nsISupports *aDelegate,
-                              const nsIID &aIID,
-                              void **aResult);
-
-    // Convenience routine, creates a class instance for a specific ProgID
-    NS_IMETHOD CreateInstance(const char *aProgID,
-                              nsISupports *aDelegate,
-                              const nsIID &aIID,
-                              void **aResult);
-
-    // Manually registry a factory for a class
-    NS_IMETHOD RegisterFactory(const nsCID &aClass,
-                               const char *aClassName,
-                               const char *aProgID,
-                               nsIFactory *aFactory,
-                               PRBool aReplace);
-
-    // Manually register a dynamically loaded component.
-    // The libraryPersistentDescriptor is what gets passed to the library
-    // self register function from ComponentManager. The format of this string
-    // is the same as nsIFileSpec::GetPersistentDescriptorString()
-    //
-    // This function will go away in favour of RegisterComponentSpec. In fact,
-    // it internally turns around and calls RegisterComponentSpec.
-    NS_IMETHOD RegisterComponent(const nsCID &aClass,
-                                 const char *aClassName,
-                                 const char *aProgID,
-                                 const char *aLibraryPersistentDescriptor,
-                                 PRBool aReplace,
-                                 PRBool aPersist);
-
-    // Register a component using its FileSpec as its identification
-    // This is the more prevalent use.
-    NS_IMETHOD RegisterComponentSpec(const nsCID &aClass,
-                                 const char *aClassName,
-                                 const char *aProgID,
-                                 nsIFileSpec *aLibrary,
-                                 PRBool aReplace,
-                                 PRBool aPersist);
-
-    // Register a component using its dllName. This could be a dll name with
-    // no path so that LD_LIBRARY_PATH on unix or PATH on win can load it. Or
-    // this could be a code fragment name on the Mac.
-    NS_IMETHOD RegisterComponentLib(const nsCID &aClass,
-                                    const char *aClassName,
-                                    const char *aProgID,
-                                    const char *adllName,
-                                    PRBool aReplace,
-                                    PRBool aPersist);
-
-    // Manually unregister a factory for a class
-    NS_IMETHOD UnregisterFactory(const nsCID &aClass,
-                                 nsIFactory *aFactory);
-
-    // Manually unregister a dynamically loaded component
-    NS_IMETHOD UnregisterComponent(const nsCID &aClass,
-                                   const char *aLibrary);
-
-    // Unload dynamically loaded factories that are not in use
-    NS_IMETHOD FreeLibraries(void);
-
-    //////////////////////////////////////////////////////////////////////////////
-    // DLL registration support
-    // Autoregistration will try only files with these extensions.
-    // All extensions are case insensitive.
-    // ".dll",    // Windows
-    // ".dso",    // Unix
-    // ".so",     // Unix
-    // ".sl",     // Unix: HP
-    // ".shlb",	// Mac
-    // ".dlm",    // new for all platforms
-    //
-    //
-    NS_IMETHOD AutoRegister(RegistrationTime when, nsIFileSpec *directory);
-    NS_IMETHOD AutoRegisterComponent(RegistrationTime when, nsIFileSpec *component);
-
-    // nsComponentManagerImpl methods:
-    nsComponentManagerImpl();
-    virtual ~nsComponentManagerImpl();
-
-    static nsComponentManagerImpl* gComponentManager;
-    nsresult Init(void);
-    nsresult PlatformPrePopulateRegistry();
-
-protected:
-    nsresult LoadFactory(nsFactoryEntry *aEntry, nsIFactory **aFactory);
-    nsFactoryEntry *GetFactoryEntry(const nsCID &aClass, PRBool checkRegistry);
-
-    nsresult SyncComponentsInDir(RegistrationTime when, nsIFileSpec *dirSpec);
-    nsresult SelfRegisterDll(nsDll *dll);
-    nsresult SelfUnregisterDll(nsDll *dll);
-    nsresult HashProgID(const char *aprogID, const nsCID &aClass);
-    nsDll *CreateCachedDll(const char *persistentDescriptor, PRUint32 modDate, PRUint32 size);
-    nsDll *CreateCachedDll(nsIFileSpec *dllSpec);
-    nsDll *CreateCachedDllName(const char *dllName);
-
-    // The following functions are the only ones that operate on the persistent
-    // registry
-    nsresult PlatformInit(void);
-    nsresult PlatformVersionCheck();
-    nsresult PlatformCreateDll(const char *fullname, nsDll* *result);
-    nsresult PlatformMarkNoComponents(nsDll *dll);
-    nsresult PlatformRegister(const char *cidString, const char *className, const char *progID, nsDll *dll);
-    nsresult PlatformUnregister(const char *cidString, const char *aLibrary);
-    nsresult PlatformFind(const nsCID &aCID, nsFactoryEntry* *result);
-    nsresult PlatformProgIDToCLSID(const char *aProgID, nsCID *aClass);
-    nsresult PlatformCLSIDToProgID(nsCID *aClass, char* *aClassName, char* *aProgID);
-    void     PlatformGetFileInfo(nsIRegistry::Key Key, PRUint32 *lastModifiedTime, PRUint32 *fileSize);
-    void     PlatformSetFileInfo(nsIRegistry::Key Key, PRUint32 lastModifiedTime, PRUint32 fileSize);
-
-protected:
-    nsHashtable*     mFactories;
-    nsHashtable*     mProgIDs;
-    PRMonitor*       mMon;
-    nsHashtable*     mDllStore;
-    nsIRegistry*     mRegistry;
-    nsIRegistry::Key mXPCOMKey;
-    nsIRegistry::Key mClassesKey;
-    nsIRegistry::Key mCLSIDKey;
-};
-
-#define NS_MAX_FILENAME_LEN	1024
-
-#define NS_ERROR_IS_DIR NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XPCOM, 24)
-
-#ifdef XP_UNIX
-/* The default registry on the unix system is $HOME/.mozilla/registry per
- * vr_findGlobalRegName(). vr_findRegFile() will create the registry file
- * if it doesn't exist. But it wont create directories.
- *
- * Hence we need to create the directory if it doesn't exist already.
- *
- * Why create it here as opposed to the app ?
- * ------------------------------------------
- * The app cannot create the directory in main() as most of the registry
- * and initialization happens due to use of static variables.
- * And we dont want to be dependent on the order in which
- * these static stuff happen.
- *
- * Permission for the $HOME/.mozilla will be Read,Write,Execute
- * for user only. Nothing to group and others.
- */
-#define NS_MOZILLA_DIR_NAME		".mozilla"
-#define NS_MOZILLA_DIR_PERMISSION	00700
-#endif /* XP_UNIX */
-
-#ifdef XP_BEOS
-#define NS_MOZILLA_DIR_NAME		"mozilla"
-#define NS_MOZILLA_DIR_PERMISSION	00700
-#endif /* XP_BEOS */
-
-/**
- * When using the registry we put a version number in it.
- * If the version number that is in the registry doesn't match
- * the following, we ignore the registry. This lets news versions
- * of the software deal with old formats of registry and not
- *
- * alpha0.20 : First time we did versioning
- * alpha0.30 : Changing autoreg to begin registration from ./components on unix
- * alpha0.40 : repository -> component manager
- * alpha0.50 : using nsIRegistry
- * alpha0.60 : xpcom 2.0 landing
- * alpha0.70 : using nsIFileSpec. PRTime -> PRUint32
- */
-#define NS_XPCOM_COMPONENT_MANAGER_VERSION_STRING "alpha0.70"
-
-////////////////////////////////////////////////////////////////////////////////
-/**
- * Class: nsFactoryEntry()
- *
- * There are two types of FactoryEntries.
- *
- * 1. {CID, dll} mapping.
- *		Factory is a consequence of the dll. These can be either session
- *		specific or persistent based on whether we write this
- *		to the registry or not.
- *
- * 2. {CID, factory} mapping
- *		These are strictly session specific and in memory only.
- */
-
-class nsFactoryEntry {
-public:
-    nsFactoryEntry(const nsCID &aClass, nsDll *dll);
-    nsFactoryEntry(const nsCID &aClass, nsIFactory *aFactory);
-    ~nsFactoryEntry();
-
-    nsresult Init(nsHashtable* dllHashtable, const nsCID &aClass, const char *aLibrary,
-                  PRTime lastModTime, PRUint32 fileSize);
-
-    nsCID cid;
-    nsIFactory *factory;
-
-    // DO NOT DELETE THIS. Many nsFactoryEntry(s) could be sharing the same Dll.
-    // This gets deleted from the dllStore going away.
-    nsDll *dll;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-#endif // nsComponentManager_h__

mozilla/xpcom/components/nsGenericFactory.cpp

@@ -1,110 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsGenericFactory.h"
-
-nsGenericFactory::nsGenericFactory(ConstructorProcPtr constructor)
-	: mConstructor(constructor), mDestructor(NULL)
-{
-	NS_INIT_ISUPPORTS();
-}
-
-nsGenericFactory::~nsGenericFactory()
-{
-	if (mDestructor != NULL)
-		(*mDestructor) ();
-}
-
-NS_METHOD nsGenericFactory::QueryInterface(const nsIID& aIID, void** aInstancePtr)
-{
-    if (NULL == aInstancePtr) {                                            
-        return NS_ERROR_NULL_POINTER;                                        
-    }                                                                      
-    if (aIID.Equals(nsIGenericFactory::GetIID()) ||
-        aIID.Equals(nsIFactory::GetIID()) ||
-    	aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
-        *aInstancePtr = (nsIGenericFactory*) this;
-        NS_ADDREF_THIS();
-        return NS_OK; 
-    } 
-    return NS_NOINTERFACE;
-}
-
-NS_IMPL_ADDREF(nsGenericFactory)
-NS_IMPL_RELEASE(nsGenericFactory)
-
-NS_IMETHODIMP nsGenericFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult)
-{
-	return mConstructor(aOuter, aIID, aResult);
-}
-
-NS_IMETHODIMP nsGenericFactory::LockFactory(PRBool aLock)
-{
-	return NS_OK;
-}
-
-NS_IMETHODIMP nsGenericFactory::SetConstructor(ConstructorProcPtr constructor)
-{
-	mConstructor = constructor;
-	return NS_OK;
-}
-
-NS_IMETHODIMP nsGenericFactory::SetDestructor(DestructorProcPtr destructor)
-{
-	mDestructor = destructor;
-	return NS_OK;
-}
-
-NS_METHOD nsGenericFactory::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
-{
-	// sorry, aggregation not spoken here.
-	nsresult res = NS_ERROR_NO_AGGREGATION;
-	if (outer == NULL) {
-		nsGenericFactory* factory = new nsGenericFactory;
-		if (factory != NULL) {
-			res = factory->QueryInterface(aIID, aInstancePtr);
-			if (res != NS_OK)
-				delete factory;
-		} else {
-			res = NS_ERROR_OUT_OF_MEMORY;
-		}
-	}
-	return res;
-}
-
-NS_COM nsresult
-NS_NewGenericFactory(nsIGenericFactory* *result,
-                     nsIGenericFactory::ConstructorProcPtr constructor,
-                     nsIGenericFactory::DestructorProcPtr destructor)
-{
-    nsresult rv;
-    nsIGenericFactory* fact;
-    rv = nsGenericFactory::Create(NULL, nsIGenericFactory::GetIID(), (void**)&fact);
-    if (NS_FAILED(rv)) return rv;
-    rv = fact->SetConstructor(constructor);
-    if (NS_FAILED(rv)) goto error;
-    rv = fact->SetDestructor(destructor);
-    if (NS_FAILED(rv)) goto error;
-    *result = fact;
-    return rv;
-
-  error:
-    NS_RELEASE(fact);
-    return rv;
-}
-

mozilla/xpcom/components/nsGenericFactory.h

@@ -1,60 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsGenericFactory_h___
-#define nsGenericFactory_h___
-
-#include "nsIGenericFactory.h"
-
-/**
- * Most factories follow this simple pattern, so why not just use a function pointer
- * for most creation operations?
- */
-class nsGenericFactory : public nsIGenericFactory {
-public:
-    static const nsCID& CID() { static nsCID cid = NS_GENERICFACTORY_CID; return cid; }
-
-	nsGenericFactory(ConstructorProcPtr constructor = NULL);
-	virtual ~nsGenericFactory();
-	
-	NS_DECL_ISUPPORTS
-	
-	NS_IMETHOD CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult);
-
-	NS_IMETHOD LockFactory(PRBool aLock);
-
-	/**
-	 * Establishes the generic factory's constructor function, which will be called
-	 * by CreateInstance.
-	 */
-    NS_IMETHOD SetConstructor(ConstructorProcPtr constructor);
-
-	/**
-	 * Establishes the generic factory's destructor function, which will be called
-	 * whe the generic factory is deleted. This is used to notify the DLL that
-	 * an instance of one of its generic factories is going away.
-	 */
-    NS_IMETHOD SetDestructor(DestructorProcPtr destructor);
-
-	static NS_METHOD Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr);
-private:
-	ConstructorProcPtr mConstructor;
-	DestructorProcPtr mDestructor;
-};
-
-#endif /* nsGenericFactory_h___ */

mozilla/xpcom/components/nsIComponentManager.h

@@ -1,286 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsIComponentManager_h__
-#define nsIComponentManager_h__
-
-#include "prtypes.h"
-#include "nsCom.h"
-#include "nsID.h"
-#include "nsError.h"
-#include "nsISupports.h"
-#include "nsIFactory.h"
-#include "nsIFileSpec.h"
-
-/*
- * Prototypes for dynamic library export functions. Your DLL/DSO needs to export
- * these methods to play in the component world.
- */
-
-extern "C" NS_EXPORT nsresult NSGetFactory(nsISupports* aServMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" NS_EXPORT PRBool   NSCanUnload(nsISupports* aServMgr);
-extern "C" NS_EXPORT nsresult NSRegisterSelf(nsISupports* aServMgr, const char *fullpath);
-extern "C" NS_EXPORT nsresult NSUnregisterSelf(nsISupports* aServMgr, const char *fullpath);
-
-typedef nsresult (*nsFactoryProc)(nsISupports* aServMgr,
-                                  const nsCID &aClass,
-                                  const char *aClassName,
-                                  const char *aProgID,
-                                  nsIFactory **aFactory);
-typedef PRBool   (*nsCanUnloadProc)(nsISupports* aServMgr);
-typedef nsresult (*nsRegisterProc)(nsISupports* aServMgr, const char *path);
-typedef nsresult (*nsUnregisterProc)(nsISupports* aServMgr, const char *path);
-
-#define NS_ICOMPONENTMANAGER_IID                     \
-{ /* 8458a740-d5dc-11d2-92fb-00e09805570f */         \
-    0x8458a740,                                      \
-    0xd5dc,                                          \
-    0x11d2,                                          \
-    {0x92, 0xfb, 0x00, 0xe0, 0x98, 0x05, 0x57, 0x0f} \
-}
-
-#define NS_COMPONENTMANAGER_CID                      \
-{ /* 91775d60-d5dc-11d2-92fb-00e09805570f */         \
-    0x91775d60,                                      \
-    0xd5dc,                                          \
-    0x11d2,                                          \
-    {0x92, 0xfb, 0x00, 0xe0, 0x98, 0x05, 0x57, 0x0f} \
-}
-
-/*
- * nsIComponentManager interface
- */
-
-class nsIComponentManager : public nsISupports {
-public:
-
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICOMPONENTMANAGER_IID)
-
-  NS_IMETHOD FindFactory(const nsCID &aClass,
-                         nsIFactory **aFactory) = 0;
-
-  // Finds a class ID for a specific Program ID
-  NS_IMETHOD ProgIDToCLSID(const char *aProgID,
-                           nsCID *aClass) = 0;
-  
-  // Finds a Program ID for a specific class ID
-  // caller frees the result with delete[]
-  NS_IMETHOD CLSIDToProgID(nsCID *aClass,
-                           char* *aClassName,
-                           char* *aProgID) = 0;
-  
-  // Creates a class instance for a specific class ID
-  NS_IMETHOD CreateInstance(const nsCID &aClass, 
-                            nsISupports *aDelegate,
-                            const nsIID &aIID,
-                            void **aResult) = 0;
-
-  // Convenience routine, creates a class instance for a specific ProgID
-  NS_IMETHOD CreateInstance(const char *aProgID,
-                            nsISupports *aDelegate,
-                            const nsIID &aIID,
-                            void **aResult) = 0;
-
-  // Manually registry a factory for a class
-  NS_IMETHOD RegisterFactory(const nsCID &aClass,
-                             const char *aClassName,
-                             const char *aProgID,
-                             nsIFactory *aFactory,
-                             PRBool aReplace) = 0;
-
-  // Manually register a dynamically loaded component.
-  // The libraryPersistentDescriptor is what gets passed to the library
-  // self register function from ComponentManager. The format of this string
-  // is the same as nsIFileSpec::GetPersistentDescriptorString()
-  //
-  // This function will go away in favour of RegisterComponentSpec. In fact,
-  // it internally turns around and calls RegisterComponentSpec.
-  NS_IMETHOD RegisterComponent(const nsCID &aClass,
-                               const char *aClassName,
-                               const char *aProgID,
-                               const char *aLibraryPersistentDescriptor,
-                               PRBool aReplace,
-                               PRBool aPersist) = 0;
-
-  // Register a component using its FileSpec as its identification
-  // This is the more prevalent use.
-  NS_IMETHOD RegisterComponentSpec(const nsCID &aClass,
-                                   const char *aClassName,
-                                   const char *aProgID,
-                                   nsIFileSpec *aLibrary,
-                                   PRBool aReplace,
-                                   PRBool aPersist) = 0;
-  
-  // Register a component using its dllName. This could be a dll name with
-  // no path so that LD_LIBRARY_PATH on unix or PATH on win can load it. Or
-  // this could be a code fragment name on the Mac.
-  NS_IMETHOD RegisterComponentLib(const nsCID &aClass,
-                                  const char *aClassName,
-                                  const char *aProgID,
-                                  const char *adllName,
-                                  PRBool aReplace,
-                                  PRBool aPersist) = 0;
-  
-  // Manually unregister a factory for a class
-  NS_IMETHOD UnregisterFactory(const nsCID &aClass,
-                               nsIFactory *aFactory) = 0;
-
-  // Manually unregister a dynamically loaded component
-  NS_IMETHOD UnregisterComponent(const nsCID &aClass,
-                                 const char *aLibrary) = 0;
-
-  // Unload dynamically loaded factories that are not in use
-  NS_IMETHOD FreeLibraries(void) = 0;
-
-  //////////////////////////////////////////////////////////////////////////////
-  // DLL registration support
-  // Autoregistration will try only files with these extensions.
-  // All extensions are case insensitive.
-  // ".dll",    // Windows
-  // ".dso",    // Unix
-  // ".so",     // Unix
-  // ".sl",     // Unix: HP
-  // ".shlb",	// Mac
-  // ".dlm",    // new for all platforms
-  //
-  // Directory and fullname are what NSPR will accept. For eg.
-  //	MAC		/Hard drive/mozilla/dist/bin
-  // 	WIN		y:\Hard drive\mozilla\dist\bin (or) y:/Hard drive/mozilla/dist/bin
-  //	UNIX	/Hard drive/mozilla/dist/bin
-  //
-  enum RegistrationTime {
-	NS_Startup = 0,
-	NS_Script = 1,
-	NS_Timer = 2
-  };
-
-  NS_IMETHOD AutoRegister(RegistrationTime when, nsIFileSpec* directory) = 0;
-  NS_IMETHOD AutoRegisterComponent(RegistrationTime when, nsIFileSpec *component) = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-extern NS_COM nsresult
-NS_GetGlobalComponentManager(nsIComponentManager* *result);
-
-////////////////////////////////////////////////////////////////////////////////
-// Global Static Component Manager Methods
-// (for when you need to link with xpcom)
-
-class NS_COM nsComponentManager {
-public:
-  static nsresult Initialize(void);
-
-  // Finds a factory for a specific class ID
-  static nsresult FindFactory(const nsCID &aClass,
-                              nsIFactory **aFactory);
-
-  // Finds a class ID for a specific Program ID
-  static nsresult ProgIDToCLSID(const char *aProgID,
-                                nsCID *aClass);
-  
-  // Finds a Program ID for a specific class ID
-  // caller frees the result with delete[]
-  static nsresult CLSIDToProgID(nsCID *aClass,
-                                char* *aClassName,
-                                char* *aProgID);
-  
-  // Creates a class instance for a specific class ID
-  static nsresult CreateInstance(const nsCID &aClass, 
-                                 nsISupports *aDelegate,
-                                 const nsIID &aIID,
-                                 void **aResult);
-
-  // Convenience routine, creates a class instance for a specific ProgID
-  static nsresult CreateInstance(const char *aProgID,
-                                 nsISupports *aDelegate,
-                                 const nsIID &aIID,
-                                 void **aResult);
-
-  // Manually registry a factory for a class
-  static nsresult RegisterFactory(const nsCID &aClass,
-                                  const char *aClassName,
-                                  const char *aProgID,
-                                  nsIFactory *aFactory,
-                                  PRBool aReplace);
-
-  // Manually register a dynamically loaded component.
-  // The libraryPersistentDescriptor is what gets passed to the library
-  // self register function from ComponentManager. The format of this string
-  // is the same as nsIFileSpec::GetPersistentDescriptorString()
-  //
-  // This function will go away in favour of RegisterComponentSpec. In fact,
-  // it internally turns around and calls RegisterComponentSpec.
-  static nsresult RegisterComponent(const nsCID &aClass,
-                               const char *aClassName,
-                               const char *aProgID,
-                               const char *aLibraryPersistentDescriptor,
-                               PRBool aReplace,
-                               PRBool aPersist);
-
-  // Register a component using its FileSpec as its identification
-  // This is the more prevalent use.
-  static nsresult RegisterComponentSpec(const nsCID &aClass,
-                                   const char *aClassName,
-                                   const char *aProgID,
-                                   nsIFileSpec *aLibrary,
-                                   PRBool aReplace,
-                                   PRBool aPersist);
-
-  // Register a component using its dllName. This could be a dll name with
-  // no path so that LD_LIBRARY_PATH on unix or PATH on win can load it. Or
-  // this could be a code fragment name on the Mac.
-  static nsresult RegisterComponentLib(const nsCID &aClass,
-                                       const char *aClassName,
-                                       const char *aProgID,
-                                       const char *adllName,
-                                       PRBool aReplace,
-                                       PRBool aPersist);
-  
-
-  // Manually unregister a factory for a class
-  static nsresult UnregisterFactory(const nsCID &aClass,
-                                    nsIFactory *aFactory);
-
-  // Manually unregister a dynamically loaded component
-  static nsresult UnregisterComponent(const nsCID &aClass,
-                                      const char *aLibrary);
-
-  // Unload dynamically loaded factories that are not in use
-  static nsresult FreeLibraries(void);
-
-  //////////////////////////////////////////////////////////////////////////////
-  // DLL registration support
-
-  // If directory is NULL, then AutoRegister will try registering components
-  // in the default components directory which is got by
-  // nsSpecialSystemDirectory(XPCOM_CurrentProcessComponentDirectory)
-  static nsresult AutoRegister(nsIComponentManager::RegistrationTime when,
-                               nsIFileSpec* directory);
-  static nsresult AutoRegisterComponent(nsIComponentManager::RegistrationTime when,
-                                        nsIFileSpec *component);
-
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-#endif

mozilla/xpcom/components/nsIFactory.h

@@ -1,39 +0,0 @@
-/*
- * DO NOT EDIT.  THIS FILE IS GENERATED FROM nsIFactory.idl
- */
-
-#ifndef __gen_nsIFactory_h__
-#define __gen_nsIFactory_h__
-
-#include "nsISupports.h" /* interface nsISupports */
-#include "nsrootidl.h" /* interface nsrootidl */
-
-#ifdef XPIDL_JS_STUBS
-#include "jsapi.h"
-#endif
-
-/* starting interface:    nsIFactory */
-
-/* {00000001-0000-0000-c000-000000000046} */
-#define NS_IFACTORY_IID_STR "00000001-0000-0000-c000-000000000046"
-#define NS_IFACTORY_IID \
-  {0x00000001, 0x0000, 0x0000, \
-    { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 }}
-
-class nsIFactory : public nsISupports {
- public: 
-  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IFACTORY_IID)
-
-  /* voidStar CreateInstance (in nsISupports aOuter, in nsIIDRef iid); */
-  NS_IMETHOD CreateInstance(nsISupports *aOuter, const nsIID & iid, void * *_retval) = 0;
-
-  /* void LockFactory (in PRBool lock); */
-  NS_IMETHOD LockFactory(PRBool lock) = 0;
-
-#ifdef XPIDL_JS_STUBS
-  static NS_EXPORT_(JSObject *) InitJSClass(JSContext *cx);
-  static NS_EXPORT_(JSObject *) GetJSObject(JSContext *cx, nsIFactory *priv);
-#endif
-};
-
-#endif /* __gen_nsIFactory_h__ */

mozilla/xpcom/components/nsIFactory.idl

@@ -1,29 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsISupports.idl"
-
-[object, uuid(00000001-0000-0000-c000-000000000046)]
-interface nsIFactory :  nsISupports {
-
-  voidStar CreateInstance(in nsISupports aOuter,
-                          in nsIIDRef iid);
-
-  void LockFactory(in PRBool lock);
-};
-

mozilla/xpcom/components/nsIGenericFactory.h

@@ -1,95 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsIGenericFactory_h___
-#define nsIGenericFactory_h___
-
-#include "nsIFactory.h"
-
-// {3bc97f01-ccdf-11d2-bab8-b548654461fc}
-#define NS_GENERICFACTORY_CID \
-{ 0x3bc97f01, 0xccdf, 0x11d2, { 0xba, 0xb8, 0xb5, 0x48, 0x65, 0x44, 0x61, 0xfc } }
-
-// {3bc97f00-ccdf-11d2-bab8-b548654461fc}
-#define NS_IGENERICFACTORY_IID \
-{ 0x3bc97f00, 0xccdf, 0x11d2, { 0xba, 0xb8, 0xb5, 0x48, 0x65, 0x44, 0x61, 0xfc } }
-
-#define NS_GENERICFACTORY_PROGID "component:/netscape/generic-factory"
-#define NS_GENERICFACTORY_CLASSNAME "Generic Factory"
-/**
- * Provides a Generic nsIFactory implementation that can be used by
- * DLLs with very simple factory needs.
- */
-class nsIGenericFactory : public nsIFactory {
-public:
-    static const nsIID& GetIID() { static nsIID iid = NS_IGENERICFACTORY_IID; return iid; }
-    
-    typedef NS_CALLBACK(ConstructorProcPtr) (nsISupports *aOuter, REFNSIID aIID, void **aResult);
-    typedef NS_CALLBACK(DestructorProcPtr) (void);
-
-	/**
-	 * Establishes the generic factory's constructor function, which will be called
-	 * by CreateInstance.
-	 */
-    NS_IMETHOD SetConstructor(ConstructorProcPtr constructor) = 0;
-
-	/**
-	 * Establishes the generic factory's destructor function, which will be called
-	 * whe the generic factory is deleted. This is used to notify the DLL that
-	 * an instance of one of its generic factories is going away.
-	 */
-    NS_IMETHOD SetDestructor(DestructorProcPtr destructor) = 0;
-};
-
-extern NS_COM nsresult
-NS_NewGenericFactory(nsIGenericFactory* *result,
-                     nsIGenericFactory::ConstructorProcPtr constructor,
-                     nsIGenericFactory::DestructorProcPtr destructor = NULL);
-
-#define NS_GENERIC_FACTORY_CONSTRUCTOR(_InstanceClass)                          \
-static nsresult                                                                 \
-_InstanceClass##Constructor(nsISupports *aOuter, REFNSIID aIID, void **aResult) \
-{                                                                               \
-    nsresult rv;                                                                \
-                                                                                \
-    _InstanceClass * inst;                                                      \
-                                                                                \
-    if (NULL == aResult) {                                                      \
-        rv = NS_ERROR_NULL_POINTER;                                             \
-        goto done;                                                              \
-    }                                                                           \
-    *aResult = NULL;                                                            \
-    if (NULL != aOuter) {                                                       \
-        rv = NS_ERROR_NO_AGGREGATION;                                           \
-        goto done;                                                              \
-    }                                                                           \
-                                                                                \
-    NS_NEWXPCOM(inst, _InstanceClass);                                          \
-    if (NULL == inst) {                                                         \
-        rv = NS_ERROR_OUT_OF_MEMORY;                                            \
-        goto done;                                                              \
-    }                                                                           \
-    NS_ADDREF(inst);                                                            \
-    rv = inst->QueryInterface(aIID, aResult);                                   \
-    NS_RELEASE(inst);                                                           \
-                                                                                \
-  done:                                                                         \
-    return rv;                                                                  \
-} 
-
-#endif /* nsIGenericFactory_h___ */

mozilla/xpcom/components/nsIRegistry.h

@@ -1,363 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#ifndef __nsIRegistry_h
-#define __nsIRegistry_h
-
-#include "nsISupports.h"
-
-// {5D41A440-8E37-11d2-8059-00600811A9C3}
-#define NS_IREGISTRY_IID { 0x5d41a440, 0x8e37, 0x11d2, { 0x80, 0x59, 0x0, 0x60, 0x8, 0x11, 0xa9, 0xc3 } }
-#define NS_REGISTRY_PROGID "component://netscape/registry"
-#define NS_REGISTRY_CLASSNAME "Mozilla Registry"
-
-// {D1B54831-AC07-11d2-805E-00600811A9C3}
-#define NS_IREGISTRYNODE_IID { 0xd1b54831, 0xac07, 0x11d2, { 0x80, 0x5e, 0x0, 0x60, 0x8, 0x11, 0xa9, 0xc3 } }
-// {5316C380-B2F8-11d2-A374-0080C6F80E4B}
-#define NS_IREGISTRYVALUE_IID { 0x5316c380, 0xb2f8, 0x11d2, { 0xa3, 0x74, 0x0, 0x80, 0xc6, 0xf8, 0xe, 0x4b } }
-
-/* be761f00-a3b0-11d2-996c-0080c7cb1081 */
-#define NS_REGISTRY_CID \
-{ 0xbe761f00, 0xa3b0, 0x11d2, \
-  {0x99, 0x6c, 0x00, 0x80, 0xc7, 0xcb, 0x10, 0x81} }
-
-
-class nsIEnumerator;
-
-/*-------------------------------- nsIRegistry ---------------------------------
-| This interface provides access to a tree of arbitrary values.                |
-|                                                                              |
-| Each node of the tree contains either a value or a subtree or both.          |
-|                                                                              |
-| The value at any of these leaf nodes can be any of these "primitive" types:  |
-|   o string (null terminated UTF string)                                      |
-|   o array of 32-bit integers                                                 |
-|   o arbitrary array of bytes                                                 |
-|   o file identifier                                                          |
-| Of course, since you can store an arbitrary array of bytes, you can put      |
-| any data you like into a registry (although you have the burden of           |
-| encoding/decoding your data in that case).                                   |
-|                                                                              |
-| Each branch of the tree is labelled with a string "key."  The entire path    |
-| from a given point of the tree to another point further down can be          |
-| presented as a single string composed of each branch's label, concatenated   |
-| to the next, with an intervening forward slash ('/').  The term "key"        |
-| refers to both specific tree branch labels and to such concatenated paths.   |
-|                                                                              |
-| The branches from a given node must have unique labels.  Distinct nodes can  |
-| have branches with the same label.                                           |
-|                                                                              |
-| For example, here's a small registry tree:                                   |
-|                                            |                                 |
-|                                           /\                                 |
-|                                         /    \                               |
-|                                       /        \                             |
-|                                     /            \                           |
-|                              "Classes"          "Users"                      |
-|                                 /                  \                         |
-|                               /                      \                       |
-|                             /                      ["joe"]                   |
-|                           /                          / \                     |
-|                          |                          /   \                    |
-|                         /\                         /     \                   |
-|                       /    \                    "joe"   "bob"                |
-|                     /        \                    /       \                  |
-|                                                  /         \                 |
-|        "{xxxx-xx-1}"       "{xxxx-xx-2}"  ["c:/joe"]   ["d:/Robert"]         |
-|             |                    |                                           |
-|            /\                   /\                                           |
-|          /    \               /    \                                         |
-|        /        \           /        \                                       |
-|    "Library" "Version"  "Library" "Version"                                  |
-|       /         \          /          \                                      |
-| ["foo.dll"]      2   ["bar.dll"]       1                                     |
-|                                                                              |
-| In this example, there are 2 keys under the root: "Classes" and "Users".     |
-| The first denotes a subtree only (which has two subtrees, ...).  The second  |
-| denotes both a value ["joe"] and two subtrees labelled "joe" and "bob".      |
-| The value at the node "/Users" is ["joe"], at "/Users/bob" is ["d:/Robert"]. |
-| The value at "/Classes/{xxxx-xx-1}/Version" is 2.                            |
-|                                                                              |
-| The registry interface provides functions that let you navigate the tree     |
-| and manipulate it's contents.                                                |
-|                                                                              |
-| Please note that the registry itself does not impose any structure or        |
-| meaning on the contents of the tree.  For example, the registry doesn't      |
-| control whether the value at the key "/Users" is the label for the subtree   |
-| with information about the last active user.  That meaning is applied by     |
-| the code that stores these values and uses them for that purpose.            |
-|                                                                              |
-| [Any resemblence between this example and actual contents of any actual      |
-| registry is purely coincidental.]                                            |
-------------------------------------------------------------------------------*/
-struct nsIRegistry : public nsISupports {
-    /*------------------------------ Constants ---------------------------------
-    | The following enumerated types and values are used by the registry       |
-    | interface.                                                               |
-    --------------------------------------------------------------------------*/
-    typedef enum {
-        String = 1,
-        Int32,
-        Bytes,
-        File
-    } DataType;
-
-    /*-------------------------------- Types -----------------------------------
-    | The following data types are used by this interface.  All are basically  |
-    | opaque types.  You obtain objects of these types via certain member      |
-    | function calls and re-use them later (without having to know what they   |
-    | contain).                                                                |
-    |                                                                          |
-    |   Key       - Placeholder to represent a particular node in a registry   |
-    |               tree.  There are 3 enumerated values that correspond to    |
-    |               specific nodes:                                            |
-    |                   Common      - Where most stuff goes.                   |
-    |                   Users       - Special subtree to hold info about       |
-    |                                 "users"; if you don't know what goes     |
-    |                                 here, don't mess with it.                |
-    |                   CurrentUser - Subtree under Users corresponding to     |
-    |                                 whatever user is designed the "current"  |
-    |                                 one; see note above.                     |
-    |               You can specify any of these enumerated values as "keys"   |
-    |               on any member function that takes a nsRegistry::Key.       |
-    |   ValueInfo - Structure describing a registry value.                     |
-    --------------------------------------------------------------------------*/
-    typedef uint32 Key;
-
-    enum WellKnownKeys { Users = 1, Common = 2, CurrentUser = 3 };
-
-    enum WellKnownRegistry {
-        ApplicationComponentRegistry = 1
-    };
-
-    struct ValueInfo {
-        DataType type;
-        uint32   length;
-    };
-
-
-    static const nsIID& GetIID() { static nsIID iid = NS_IREGISTRY_IID; return iid; }
-
-    /*--------------------------- Opening/Closing ------------------------------
-    | These functions open the specified registry file (Open() with a non-null |
-    | argument) or the default "standard" registry file (Open() with a null    |
-    | argument or OpenDefault()).                                              |
-    |                                                                          |
-    | Once opened, you can access the registry contents via the read/write     |
-    | or query functions.                                                      |
-    |                                                                          |
-    | The registry file will be closed automatically when the registry object  |
-    | is destroyed.  You can close the file prior to that by using the         |
-    | Close() function.                                                        |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD Open( const char *regFile = 0 ) = 0;
-    NS_IMETHOD OpenWellKnownRegistry( uint32 regid ) = 0;
-    NS_IMETHOD OpenDefault() = 0;
-    NS_IMETHOD Close() = 0;
-
-    /*----------------------- Reading/Writing Values ---------------------------
-    | These functions read/write the registry values at a given node.          |
-    |                                                                          |
-    | All functions require you to specify where in the registry key to        |
-    | get/set the value.  The location is specified using two components:      |
-    |   o A "base key" indicating where to start from; this is a value of type |
-    |     nsIRegistry::Key.  You use either one of the special "root" key      |
-    |     values or a subkey obtained via some other member function call.     |
-    |   o A "relative path," expressed as a sequence of subtree names          |
-    |     separated by forward slashes.  This path describes how to get from   |
-    |     the base key to the node at which you want to store the data.  This  |
-    |     component can be a null pointer which means the value goes directly  |
-    |     at the node denoted by the base key.                                 |
-    |                                                                          |
-    | When you request a value of a given type, the data stored at the         |
-    | specified node must be of the type requested.  If not, an error results. |
-    |                                                                          |
-    | GetString - Obtains a newly allocated copy of a string type value.  The  |
-    |             caller is obligated to free the returned string using        |
-    |             PR_Free.                                                     |
-    | SetString - Stores the argument string at the specified node.            |
-    | GetInt    - Obtains an int32 value at the specified node.  The result    |
-    |             is returned into an int32 location you specify.              |
-    | SetInt    - Stores a given int32 value at a node.                        |
-    | GetBytes  - Obtains a byte array value; this returns both an allocated   |
-    |             array of bytes and a length (necessary because there may be  |
-    |             embedded null bytes in the array).  You must free the        |
-    |             resulting array using PR_Free.                               |
-    | SetBytes  - Stores a given array of bytes; you specify the bytes via a   |
-    |             pointer and a length.                                        |
-    | GetIntArray - Obtains the array of int32 values stored at a given node.  |
-    |             The result is composed of two values: a pointer to an        |
-    |             array of integer values (which must be freed using           |
-    |             PR_Free) and the number of elements in that array.           |
-    | SetIntArray - Stores a set of int32 values at a given node.  You must    |
-    |             provide a pointer to the array and the number of entries.    |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD GetString( Key baseKey, const char *path, char **result ) = 0;
-    NS_IMETHOD SetString( Key baseKey, const char *path, const char *value ) = 0;
-    NS_IMETHOD GetInt( Key baseKey, const char *path, int32 *result ) = 0;
-    NS_IMETHOD SetInt( Key baseKey, const char *path, int32 value ) = 0;
-    NS_IMETHOD GetBytes( Key baseKey, const char *path, void **result, uint32 *len ) = 0;
-    NS_IMETHOD SetBytes( Key baseKey, const char *path, void *value, uint32 len ) = 0;
-    NS_IMETHOD GetIntArray( Key baseKey, const char *path, int32 **result, uint32 *len ) = 0;
-    NS_IMETHOD SetIntArray( Key baseKey, const char *path, const int32 *value, uint32 len ) = 0;
-
-    /*------------------------------ Navigation --------------------------------
-    | These functions let you navigate through the registry tree, querying     |
-    | its contents.                                                            |
-    |                                                                          |
-    | As above, all these functions requires a starting tree location ("base   |
-    | key")  specified as a nsIRegistry::Key.  Some also require a path        |
-    | name to locate the registry node location relative to this base key.     |
-    |                                                                          |
-    | AddSubtree           - Adds a new registry subtree at the specified      |
-    |                        location.  Returns the resulting key in           |
-    |                        the location specified by the third argument      |
-    |                        (unless that pointer is 0).                       |
-	| AddSubtreeRaw        - Adds a new registry subtree at the specified      |
-    |                        location.  Returns the resulting key in           |
-    |                        the location specified by the third argument      |
-    |                        (unless that pointer is 0).                       |
-	|                        Does not interpret special chars in key names.    |
-    |                                                                          |
-    | RemoveSubtree        - Removes the specified registry subtree or         |
-    |                        value at the specified location.                  |
-    | RemoveSubtreeRaw     - Removes the specified registry subtree or         |
-    |                        value at the specified location.                  |
-    |                        Does not interpret special chars in key names.    |
-    |                                                                          |
-    | GetSubtree           - Returns a nsIRegistry::Key that can be used       |
-    |                        to refer to the specified registry location.      |
-	| GetSubtreeRaw        - Returns a nsIRegistry::Key that can be used       |
-    |                        to refer to the specified registry location.      |
-	|                        Does not interpret special chars in key names.    |
-    |                                                                          |
-    | EnumerateSubtrees    - Returns a nsIEnumerator object that you can       |
-    |                        use to enumerate all the subtrees descending      |
-    |                        from a specified location.  You must free the     |
-    |                        enumerator via Release() when you're done with    |
-    |                        it.                                               |
-    | EnumerateAllSubtrees - Like EnumerateSubtrees, but will recursively      |
-    |                        enumerate lower-level subtrees, too.              |
-    | GetValueInfo         - Returns a uint32 value that designates the type   |
-    |                        of data stored at this location in the registry;  |
-    |                        the possible values are defined by the enumerated |
-    |                        type nsIRegistry::DataType.                       |
-    | GetValueLength       - Returns a uint32 value that indicates the length  |
-    |                        of this registry value; the length is the number  |
-    |                        of characters (for Strings), the number of bytes  |
-    |                        (for Bytes), or the number of int32 values (for   |
-    |                        Int32).                                           |
-    | EnumerateValues      - Returns a nsIEnumerator that you can use to       |
-    |                        enumerate all the value nodes descending from     |
-    |                        a specified location.                             |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD AddSubtree( Key baseKey, const char *path, Key *result ) = 0;
-    NS_IMETHOD RemoveSubtree( Key baseKey, const char *path ) = 0;
-    NS_IMETHOD GetSubtree( Key baseKey, const char *path, Key *result ) = 0;
-
-	NS_IMETHOD AddSubtreeRaw( Key baseKey, const char *keyname, Key *result ) = 0;
-    NS_IMETHOD RemoveSubtreeRaw( Key baseKey, const char *keyname ) = 0;
-	NS_IMETHOD GetSubtreeRaw( Key baseKey, const char *keyname, Key *result ) = 0;
-
-    NS_IMETHOD EnumerateSubtrees( Key baseKey, nsIEnumerator **result ) = 0;
-    NS_IMETHOD EnumerateAllSubtrees( Key baseKey, nsIEnumerator **result ) = 0;
-
-    NS_IMETHOD GetValueType( Key baseKey, const char *path, uint32 *result ) = 0;
-    NS_IMETHOD GetValueLength( Key baseKey, const char *path, uint32 *result ) = 0;
-
-    NS_IMETHOD EnumerateValues( Key baseKey, nsIEnumerator **result ) = 0;
-
-    /*------------------------------ User Name ---------------------------------
-    | These functions manipulate the current "user name."  This value controls |
-    | the behavior of certain registry functions (namely, ?).                  |
-    |                                                                          |
-    | GetCurrentUserName allocates a copy of the current user name (which the  |
-    | caller should free using PR_Free).                                       |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD GetCurrentUserName( char **result ) = 0;
-    NS_IMETHOD SetCurrentUserName( const char *name ) = 0;
-
-    /*------------------------------ Utilities ---------------------------------
-    | Various utility functions:                                               |
-    |                                                                          |
-    | Pack() is used to compress the contents of an open registry file.        |
-    --------------------------------------------------------------------------*/
-    NS_IMETHOD Pack() = 0;
-
-}; // nsIRegistry
-
-/*------------------------------ nsIRegistryNode -------------------------------
-| This interface is implemented by all the objects obtained from the           |
-| nsIEnumerators that nsIRegistry provides when you call either of the         |
-| subtree enumeration functions EnumerateSubtrees or EnumerateAllSubtrees.     |
-|                                                                              |
-| You can call this function to get the name of this subtree.  This is the     |
-| relative path from the base key from which you got this interface.           |
-|                                                                              |
-|   GetName - Returns the path name of this node; this is the relative path    |
-|             from the base key from which this subtree was obtained.  The     |
-|             function allocates a copy of the name; the caller must free it   |
-|             using PR_Free.                                                   |
-------------------------------------------------------------------------------*/
-struct nsIRegistryNode : public nsISupports {
-    NS_DEFINE_STATIC_IID_ACCESSOR(NS_IREGISTRYNODE_IID)
-    NS_IMETHOD GetName( char **result ) = 0;
-    NS_IMETHOD GetKey( nsIRegistry::Key *r_key ) = 0;
-}; // nsIRegistryNode
-
-/*------------------------------ nsIRegistryValue ------------------------------
-| This interface is implemented by the objects obtained from the               |
-| nsIEnumerators that nsIRegistry provides when you call the                   |
-| EnumerateValues function.  An object supporting this interface is            |
-| returned when you call the CurrentItem() function on that enumerator.        |
-|                                                                              |
-| You use the member functions of this interface to obtain information         |
-| about each registry value.                                                   |
-|                                                                              |
-|   GetName      - Returns the path name of this node; this is the relative    |
-|                  path\ from the base key from which this value was obtained. |
-|                  The function allocates a copy of the name; the caller must  |
-|                  subsequently free it via PR_Free.                           |
-|   GetValueType - Returns (into a location provided by the caller) the type   |
-|                  of the value; the types are defined by the enumerated       |
-|                  type nsIRegistry::DataType.                                 |
-|   GetValueLength - Returns a uint32 value that indicates the length          |
-|                    of this registry value; the length is the number          |
-|                    of characters (for Strings), the number of bytes          |
-|                    (for Bytes), or the number of int32 values (for           |
-|                    Int32).                                                   |
-------------------------------------------------------------------------------*/
-struct nsIRegistryValue : public nsISupports {
-    NS_IMETHOD GetName( char **result ) = 0;
-    NS_IMETHOD GetValueType( uint32 *result ) = 0;
-    NS_IMETHOD GetValueLength( uint32 *result ) = 0;
-}; // nsIRegistryEntry
-
-
-/*------------------------------- Error Codes ----------------------------------
-------------------------------------------------------------------------------*/
-#define NS_ERROR_REG_BADTYPE          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 1 )
-#define NS_ERROR_REG_NO_MORE          NS_ERROR_GENERATE_SUCCESS( NS_ERROR_MODULE_REG, 2 )
-#define NS_ERROR_REG_NOT_FOUND        NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 3 )
-#define NS_ERROR_REG_NOFILE	          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 4 )
-#define NS_ERROR_REG_BUFFER_TOO_SMALL NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 5 )
-#define NS_ERROR_REG_NAME_TOO_LONG    NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 6 )
-#define NS_ERROR_REG_NO_PATH          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 7 )
-#define NS_ERROR_REG_READ_ONLY        NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 8 )
-#define NS_ERROR_REG_BAD_UTF8         NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 9 )
-
-#endif

mozilla/xpcom/components/nsIServiceManager.h

@@ -1,343 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsIServiceManager_h___
-#define nsIServiceManager_h___
-
-#include "nsIComponentManager.h"
-#include "nsID.h"
-
-class nsIShutdownListener;
-
-#define NS_ISERVICEMANAGER_IID                       \
-{ /* cf0df3b0-3401-11d2-8163-006008119d7a */         \
-    0xcf0df3b0,                                      \
-    0x3401,                                          \
-    0x11d2,                                          \
-    {0x81, 0x63, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a} \
-}
-
-/**
- * The nsIServiceManager manager interface provides a means to obtain
- * global services in an application. The service manager depends on the 
- * repository to find and instantiate factories to obtain services.
- *
- * Users of the service manager must first obtain a pointer to the global
- * service manager by calling NS_GetGlobalServiceManager. After that, 
- * they can request specific services by calling GetService. When they are
- * finished with a service the release it by calling ReleaseService (instead
- * of releasing the service object directly):
- *
- *    nsICacheManager* cm;
- *    nsServiceManager::GetService(kCacheManagerCID, kICacheManagerIID, (nsISupports**)&cm);
- *
- *    ... use cm, and then sometime later ...
- *
- *    nsServiceManager::ReleaseService(kCacheManagerCID, cm);
- *
- * A user of a service may keep references to particular services indefinitely
- * and only must call ReleaseService when it shuts down. However if the user
- * wishes to voluntarily cooperate with the shutdown of the service it is 
- * using, it may supply an nsIShutdownListener to provide for asynchronous
- * release of the services it is using. The shutdown listener's OnShutdown
- * method will be called for a service that is being shut down, and it is
- * its responsiblity to release references obtained from that service if at
- * all possible.
- *
- * The process of shutting down a particular service is initiated by calling
- * the service manager's ShutdownService method. This will iterate through
- * all the registered shutdown listeners for the service being shut down, and
- * then will attempt to unload the library associated with the service if
- * possible. The status result of ShutdownService indicates whether the 
- * service was successfully shut down, failed, or was not in service.
- *
- * XXX QUESTIONS:
- * - Should a "service" be more than nsISupports? Should it be a factory 
- *   and/or have Startup(), Shutdown(), etc.
- * - If the asynchronous OnShutdown operation gets called, does the user
- *   of a service still need to call ReleaseService? (Or should they _not_
- *   call it?)
- */
-class nsIServiceManager : public nsISupports {
-public:
-
-    NS_DEFINE_STATIC_IID_ACCESSOR(NS_ISERVICEMANAGER_IID);
-
-    /**
-     * RegisterService may be called explicitly to register a service
-     * with the service manager. If a service is not registered explicitly,
-     * the component manager will be used to create an instance according
-     * to the class ID specified.
-     */
-    NS_IMETHOD
-    RegisterService(const nsCID& aClass, nsISupports* aService) = 0;
-
-    /**
-     * Requests a service to be shut down, possibly unloading its DLL.
-     *
-     * @returns NS_OK - if shutdown was successful and service was unloaded,
-     * @returns NS_ERROR_SERVICE_NOT_FOUND - if shutdown failed because
-     *          the service was not currently loaded
-     * @returns NS_ERROR_SERVICE_IN_USE - if shutdown failed because some
-     *          user of the service wouldn't voluntarily release it by using
-     *          a shutdown listener.
-     */
-    NS_IMETHOD
-    UnregisterService(const nsCID& aClass) = 0;
-
-    NS_IMETHOD
-    GetService(const nsCID& aClass, const nsIID& aIID,
-               nsISupports* *result,
-               nsIShutdownListener* shutdownListener = nsnull) = 0;
-
-    NS_IMETHOD
-    ReleaseService(const nsCID& aClass, nsISupports* service,
-                   nsIShutdownListener* shutdownListener = nsnull) = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-    // let's do it again, this time with ProgIDs...
-
-    NS_IMETHOD
-    RegisterService(const char* aProgID, nsISupports* aService) = 0;
-
-    NS_IMETHOD
-    UnregisterService(const char* aProgID) = 0;
-
-    NS_IMETHOD
-    GetService(const char* aProgID, const nsIID& aIID,
-               nsISupports* *result,
-               nsIShutdownListener* shutdownListener = nsnull) = 0;
-
-    NS_IMETHOD
-    ReleaseService(const char* aProgID, nsISupports* service,
-                   nsIShutdownListener* shutdownListener = nsnull) = 0;
-
-};
-
-#define NS_ERROR_SERVICE_NOT_FOUND      NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_XPCOM, 22)
-#define NS_ERROR_SERVICE_IN_USE         NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_XPCOM, 23)
-
-////////////////////////////////////////////////////////////////////////////////
-
-#define NS_ISHUTDOWNLISTENER_IID                     \
-{ /* 56decae0-3406-11d2-8163-006008119d7a */         \
-    0x56decae0,                                      \
-    0x3406,                                          \
-    0x11d2,                                          \
-    {0x81, 0x63, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a} \
-}
-
-class nsIShutdownListener : public nsISupports {
-public:
-
-    NS_DEFINE_STATIC_IID_ACCESSOR(NS_ISHUTDOWNLISTENER_IID);
-
-    NS_IMETHOD
-    OnShutdown(const nsCID& aClass, nsISupports* service) = 0;
-
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Interface to Global Services
-
-class NS_COM 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 = nsnull);
-
-    static nsresult
-    ReleaseService(const nsCID& aClass, nsISupports* service,
-                   nsIShutdownListener* shutdownListener = nsnull);
-
-    ////////////////////////////////////////////////////////////////////////////
-    // let's do it again, this time with ProgIDs...
-
-    static nsresult
-    RegisterService(const char* aProgID, nsISupports* aService);
-
-    static nsresult
-    UnregisterService(const char* aProgID);
-
-    static nsresult
-    GetService(const char* aProgID, const nsIID& aIID,
-               nsISupports* *result,
-               nsIShutdownListener* shutdownListener = nsnull);
-
-    static nsresult
-    ReleaseService(const char* aProgID, nsISupports* service,
-                   nsIShutdownListener* shutdownListener = nsnull);
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    static nsresult GetGlobalServiceManager(nsIServiceManager* *result);
-
-    // This method can be called when shutting down the application. It  
-    // releases all the global services, and deletes the global service manager.
-    static nsresult ShutdownGlobalServiceManager(nsIServiceManager* *result);
-
-    static nsIServiceManager* mGlobalServiceManager;
-
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// NS_WITH_SERVICE: macro to make using services easier. 
-// Now you can replace this:
-//  {
-//      nsIMyService* service;
-//      rv = nsServiceManager::GetService(kMyServiceCID, nsIMyService::GetIID(),
-//                                        &service);
-//      if (NS_FAILED(rv)) return rv;
-//      service->Doit(...);     // use my service
-//      rv = nsServiceManager::ReleaseService(kMyServiceCID, service);
-//  }
-// with this:
-//  {
-//      NS_WITH_SERVICE(nsIMyService, service, kMyServiceCID, &rv);
-//      if (NS_FAILED(rv)) return rv;
-//      service->Doit(...);     // use my service
-//  }
-// and the automatic destructor will take care of releasing the service. 
-// 
-// Note that this macro requires you to link with the xpcom DLL to pick up the
-// static member functions from nsServiceManager. For situations where you're 
-// passed an nsISupports that is an nsIComponentManager (such as in a DLL's 
-// NSRegisterSelf or NSUnregisterSelf entry points) you can use the following
-// macro instead:
-// 
-//   NSRegisterSelf(nsISupports* servMgr, const char* path) {
-//      NS_WITH_SERVICE1(nsIComponentManager, compMgr, servMgr,
-//                       kComponentManagerCID, &rv);
-//      if (NS_FAILED(rv)) return rv;
-//      compMgr->RegisterComponent(...);     // use the service
-//  }
-//
-// Note that both NS_WITH_SERVICE and NS_WITH_SERVICE1 can be used with a
-// "progid" as well as a "clsid"; for example,
-//
-//   nsresult rv;
-//   NS_WITH_SERVICE(nsIObserverService,
-//                   observer,
-//                   "component://netscape/observer-service", /* or NS_OBSERVERSERVICE_PROGID */
-//                   &rv);
-//
-
-
-#define NS_WITH_SERVICE(T, var, cid, rvAddr)      \
-  nsService _serv##var(cid, T::GetIID(), rvAddr); \
-  T* var = (T*)(nsISupports*)_serv##var;
-
-#define NS_WITH_SERVICE1(T, var, isupports, cid, rvAddr)     \
-  nsService _serv##var(isupports, cid, T::GetIID(), rvAddr); \
-  T* var = (T*)(nsISupports*)_serv##var;
-
-class nsService {
-protected:
-  nsCID mCID;
-  nsISupports* mService;
-
-public:
-  nsService(nsISupports* aServMgr, const nsCID& aClass, const nsIID& aIID, nsresult *rv)
-    : mCID(aClass), mService(0)
-  {
-    nsIServiceManager* servMgr;
-    *rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void**)&servMgr);
-    if (NS_SUCCEEDED(*rv)) {
-      *rv = servMgr->GetService(mCID, aIID, &mService);
-      NS_RELEASE(servMgr);
-    }
-  }
-
-  nsService(nsISupports* aServMgr, const char* aProgID, const nsIID& aIID, nsresult *rv)
-    : mService(0)
-  {
-    *rv = nsComponentManager::ProgIDToCLSID(aProgID, &mCID);
-    if (NS_FAILED(*rv)) return;
-  
-    nsIServiceManager* servMgr;
-    *rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void**)&servMgr);
-    if (NS_SUCCEEDED(*rv)) {
-      *rv = servMgr->GetService(mCID, aIID, &mService);
-      NS_RELEASE(servMgr);
-    }
-  }
-
-  nsService(const nsCID& aClass, const nsIID& aIID, nsresult *rv)
-    : mCID(aClass), mService(0) {
-    *rv = nsServiceManager::GetService(aClass, aIID,
-                                       (nsISupports**)&mService);
-  }
-
-  nsService(const char* aProgID, const nsIID& aIID, nsresult *rv)
-    : mService(0)
-  {
-    *rv = nsComponentManager::ProgIDToCLSID(aProgID, &mCID);
-    if (NS_FAILED(*rv)) return;
-
-    *rv = nsServiceManager::GetService(mCID, aIID,
-                                       (nsISupports**)&mService);
-  }
-
-  ~nsService() {
-    if (mService) {       // mService could be null if the constructor fails
-      nsresult rv = NS_OK;
-      rv = nsServiceManager::ReleaseService(mCID, mService);
-    }
-  }
-
-  nsISupports* operator->() const {
-    NS_PRECONDITION(mService != 0, "Your code should test the error result from the constructor.");
-    return mService;
-  }
-
-  PRBool operator==(const nsISupports* other) {
-    return mService == other;
-  }
-
-  operator nsISupports*() const {
-    return mService;
-  }
-
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// NS_NewServiceManager: For when you want to create a service manager
-// in a given context.
-
-extern NS_COM nsresult
-NS_NewServiceManager(nsIServiceManager* *result);
-
-////////////////////////////////////////////////////////////////////////////////
-// Initialization of XPCOM. Creates the global ComponentManager, ServiceManager
-// and registers xpcom components with the ComponentManager. Should be called
-// before any call can be made to XPCOM. Currently we are coping with this
-// not being called and internally initializing XPCOM if not already.
-extern NS_COM nsresult
-NS_InitXPCOM(nsIServiceManager* *result);
-
-////////////////////////////////////////////////////////////////////////////////
-
-#endif /* nsIServiceManager_h___ */

mozilla/xpcom/components/nsMacRepository.h

@@ -1,164 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-#ifdef XP_MAC
-#ifdef MOZ_NGLAYOUT
-
-#error "nsMacRepository.h became obsolete when the shared lib conversion was completed."
-
-// The Mac NGLayout is not based on shared libraries yet.
-// All the DLLs are built as static libraries and we present them as
-// shared libraries by redefining PR_LoadLibrary(), PR_UnloadLibrary()
-// and PR_FindSymbol() below.
-//
-// If you add or remove shared libraries on other platforms, you must
-//	- Add the library name to the defines below.
-//	- Rename the "NSGetFactory" and "NSCanUnload" procs for the Mac:
-//    just append the library name to the function name.
-//	- Add the library and its procs to the static list below.
-
-
-typedef struct MacLibrary
-{
-	char *			name;
-	nsFactoryProc	factoryProc;
-	nsCanUnloadProc	unloadProc;
-} MacLibrary;
-
-// library names
-#define WIDGET_DLL		"WIDGET_DLL"
-#define GFXWIN_DLL		"GFXWIN_DLL"
-#define VIEW_DLL		"VIEW_DLL"
-#define WEB_DLL			"WEB_DLL"
-#define PLUGIN_DLL		"PLUGIN_DLL"
-#define PREF_DLL		"PREF_DLL"
-#define PARSER_DLL		"PARSER_DLL"
-#define DOM_DLL    		"DOM_DLL"
-#define LAYOUT_DLL		"LAYOUT_DLL"
-#define NETLIB_DLL		"NETLIB_DLL"
-#define EDITOR_DLL		"EDITOR_DLL"
-
-#ifdef IMPL_MAC_REPOSITORY
-
-extern "C" nsresult		NSGetFactory_WIDGET_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_GFXWIN_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_VIEW_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_WEB_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-#if 0
-extern "C" nsresult		NSGetFactory_PLUGIN_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-#endif
-extern "C" nsresult		NSGetFactory_PREF_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_PARSER_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_DOM_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_LAYOUT_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_NETLIB_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-extern "C" nsresult		NSGetFactory_EDITOR_DLL(nsISupports* serviceMgr,
-                                           const nsCID &aClass,
-                                           const char *aClassName,
-                                           const char *aProgID,
-                                           nsIFactory **aFactory);
-
-extern "C" PRBool		NSCanUnload_PREF_DLL(void);
-
-// library list
-static MacLibrary	libraries[] = {
-#if 0
-	WIDGET_DLL,		NSGetFactory_WIDGET_DLL,	NULL,
-	GFXWIN_DLL,		NSGetFactory_GFXWIN_DLL,	NULL,
-	VIEW_DLL,		NSGetFactory_VIEW_DLL,		NULL,
-	WEB_DLL,		NSGetFactory_WEB_DLL,		NULL,
-	//PLUGIN_DLL,		NSGetFactory_PLUGIN_DLL,	NULL,
-	PREF_DLL,		NSGetFactory_PREF_DLL,		NSCanUnload_PREF_DLL,
-	PARSER_DLL,		NSGetFactory_PARSER_DLL,	NULL,
-	DOM_DLL,		NSGetFactory_DOM_DLL,		NULL,
-	LAYOUT_DLL,		NSGetFactory_LAYOUT_DLL,	NULL,
-	NETLIB_DLL,		NSGetFactory_NETLIB_DLL,	NULL,
-	//EDITOR_DLL,		NSGetFactory_EDITOR_DLL,	NULL,		// FIX ME
-#endif
-	NULL
-};
-
-static void* FindMacSymbol(char* libName, const char *symbolName)
-{
-	MacLibrary * macLib;
-
-	for (macLib = libraries; ; macLib ++)
-	{
-		if (macLib->name == NULL)
-			return NULL;
-
-		if (PL_strcmp(macLib->name, libName) == 0)
-			break;
-	}
-
-	if (PL_strcmp(symbolName, "NSGetFactory") == 0) {
-		return macLib->factoryProc;
-	}
-	else if (PL_strcmp(symbolName, "NSCanUnload") == 0) {
-		return macLib->unloadProc;
-	}
-	return NULL;
-}
-
-#define PR_LoadLibrary(libName)			(PRLibrary *)libName
-#define PR_UnloadLibrary(lib)			lib = NULL
-#define PR_FindSymbol(lib, symbolName)	FindMacSymbol((char*)lib, symbolName)
-
-#endif // IMPL_MAC_REPOSITORY
-
-#endif // MOZ_NGLAYOUT
-#endif // XP_MAC

mozilla/xpcom/components/nsRepository.cpp

@@ -1,188 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsIComponentManager.h"
-
-nsresult
-nsComponentManager::Initialize(void)
-{
-    return NS_OK;
-}
-
-nsresult
-nsComponentManager::FindFactory(const nsCID &aClass,
-                                nsIFactory **aFactory)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->FindFactory(aClass, aFactory);
-}
-
-nsresult
-nsComponentManager::ProgIDToCLSID(const char *aProgID,
-                                  nsCID *aClass)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->ProgIDToCLSID(aProgID, aClass);
-}
-  
-nsresult
-nsComponentManager::CLSIDToProgID(nsCID *aClass,
-                                  char* *aClassName,
-                                  char* *aProgID)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->CLSIDToProgID(aClass, aClassName, aProgID);
-}
-  
-nsresult
-nsComponentManager::CreateInstance(const nsCID &aClass, 
-                                   nsISupports *aDelegate,
-                                   const nsIID &aIID,
-                                   void **aResult)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->CreateInstance(aClass, aDelegate, aIID, aResult);
-}
-
-nsresult
-nsComponentManager::CreateInstance(const char *aProgID,
-                                   nsISupports *aDelegate,
-                                   const nsIID &aIID,
-                                   void **aResult)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->CreateInstance(aProgID, aDelegate, aIID, aResult);
-}
-
-nsresult
-nsComponentManager::RegisterFactory(const nsCID &aClass,
-                                    const char *aClassName,
-                                    const char *aProgID,
-                                    nsIFactory *aFactory,
-                                    PRBool aReplace)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->RegisterFactory(aClass, aClassName, aProgID,
-                               aFactory, aReplace);
-}
-
-nsresult
-nsComponentManager::RegisterComponent(const nsCID &aClass,
-                                      const char *aClassName,
-                                      const char *aProgID,
-                                      const char *aLibraryPersistentDescriptor,
-                                      PRBool aReplace,
-                                      PRBool aPersist)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->RegisterComponent(aClass, aClassName, aProgID,
-                                 aLibraryPersistentDescriptor, aReplace, aPersist);
-}
-
-nsresult
-nsComponentManager::RegisterComponentSpec(const nsCID &aClass,
-                                      const char *aClassName,
-                                      const char *aProgID,
-                                      nsIFileSpec *aLibrary,
-                                      PRBool aReplace,
-                                      PRBool aPersist)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->RegisterComponentSpec(aClass, aClassName, aProgID,
-                                     aLibrary, aReplace, aPersist);
-}
-
-nsresult
-nsComponentManager::RegisterComponentLib(const nsCID &aClass,
-                                         const char *aClassName,
-                                         const char *aProgID,
-                                         const char *adllName,
-                                         PRBool aReplace,
-                                         PRBool aPersist)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->RegisterComponentLib(aClass, aClassName, aProgID,
-                                     adllName, aReplace, aPersist);
-}
-
-nsresult
-nsComponentManager::UnregisterFactory(const nsCID &aClass,
-                                      nsIFactory *aFactory)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->UnregisterFactory(aClass, aFactory);
-}
-
-nsresult
-nsComponentManager::UnregisterComponent(const nsCID &aClass,
-                                        const char *aLibrary)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->UnregisterComponent(aClass, aLibrary);
-}
-
-nsresult
-nsComponentManager::FreeLibraries(void)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->FreeLibraries();
-}
-
-nsresult
-nsComponentManager::AutoRegister(nsIComponentManager::RegistrationTime when,
-                                 nsIFileSpec *directory)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->AutoRegister(when, directory);
-}
-
-nsresult
-nsComponentManager::AutoRegisterComponent(nsIComponentManager::RegistrationTime when,
-                                          nsIFileSpec *fullname)
-{
-    nsIComponentManager* cm;
-    nsresult rv = NS_GetGlobalComponentManager(&cm);
-    if (NS_FAILED(rv)) return rv;
-    return cm->AutoRegisterComponent(when, fullname);
-}

mozilla/xpcom/components/nsRepository.h

@@ -1,28 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef __nsRespository_h
-#define __nsRespository_h
-
-#include "nsIComponentManager.h"
-
-// XXX nsRepository is obsolete! Use nsComponentManager now!
-
-#define nsRepository            nsComponentManager
-
-#endif

mozilla/xpcom/components/nsServiceManager.cpp

@@ -1,518 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsIServiceManager.h"
-#include "nsVector.h"
-#include "nsHashtable.h"
-#include "prcmon.h"
-#include "prthread.h" /* XXX: only used for the NSPR initialization hack (rick) */
-
-static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
-
-class nsServiceEntry {
-public:
-
-    nsServiceEntry(const nsCID& cid, nsISupports* service);
-    ~nsServiceEntry();
-
-    nsresult AddListener(nsIShutdownListener* listener);
-    nsresult RemoveListener(nsIShutdownListener* listener);
-    nsresult NotifyListeners(void);
-
-    const nsCID& mClassID;
-    nsISupports* mService;
-    nsVector* mListeners;        // nsVector<nsIShutdownListener>
-    PRBool mShuttingDown;
-
-};
-
-nsServiceEntry::nsServiceEntry(const nsCID& cid, nsISupports* service)
-    : mClassID(cid), mService(service), mListeners(NULL), mShuttingDown(PR_FALSE)
-{
-}
-
-nsServiceEntry::~nsServiceEntry()
-{
-    if (mListeners) {
-        NS_ASSERTION(mListeners->GetSize() == 0, "listeners not removed or notified");
-#if 0
-        PRUint32 size = mListeners->GetSize();
-        for (PRUint32 i = 0; i < size; i++) {
-            nsIShutdownListener* listener = (nsIShutdownListener*)(*mListeners)[i];
-            NS_RELEASE(listener);
-        }
-#endif
-        delete mListeners;
-    }
-}
-
-nsresult
-nsServiceEntry::AddListener(nsIShutdownListener* listener)
-{
-    if (listener == NULL)
-        return NS_OK;
-    if (mListeners == NULL) {
-        mListeners = new nsVector();
-        if (mListeners == NULL)
-            return NS_ERROR_OUT_OF_MEMORY;
-    }
-    PRInt32 rv = mListeners->Add(listener);
-    NS_ADDREF(listener);
-    return rv == -1 ? NS_ERROR_FAILURE : NS_OK;
-}
-
-nsresult
-nsServiceEntry::RemoveListener(nsIShutdownListener* listener)
-{
-    if (listener == NULL)
-        return NS_OK;
-    NS_ASSERTION(mListeners, "no listeners added yet");
-    PRUint32 size = mListeners->GetSize();
-    for (PRUint32 i = 0; i < size; i++) {
-        if ((*mListeners)[i] == listener) {
-            mListeners->Remove(i);
-            NS_RELEASE(listener);
-            return NS_OK;
-        }
-    }
-    NS_ASSERTION(0, "unregistered shutdown listener");
-    return NS_ERROR_FAILURE;
-}
-
-nsresult
-nsServiceEntry::NotifyListeners(void)
-{
-    if (mListeners) {
-        PRUint32 size = mListeners->GetSize();
-        for (PRUint32 i = 0; i < size; i++) {
-            nsIShutdownListener* listener = (nsIShutdownListener*)(*mListeners)[0];
-            nsresult rv = listener->OnShutdown(mClassID, mService);
-            if (NS_FAILED(rv)) return rv;
-            NS_RELEASE(listener);
-            mListeners->Remove(0);
-        }
-        NS_ASSERTION(mListeners->GetSize() == 0, "failed to notify all listeners");
-        delete mListeners;
-        mListeners = NULL;
-    }
-    return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-class nsServiceManagerImpl : public nsIServiceManager {
-public:
-
-    NS_IMETHOD
-    RegisterService(const nsCID& aClass, nsISupports* aService);
-
-    NS_IMETHOD
-    UnregisterService(const nsCID& aClass);
-
-    NS_IMETHOD
-    GetService(const nsCID& aClass, const nsIID& aIID,
-               nsISupports* *result,
-               nsIShutdownListener* shutdownListener = NULL);
-
-    NS_IMETHOD
-    ReleaseService(const nsCID& aClass, nsISupports* service,
-                   nsIShutdownListener* shutdownListener = NULL);
-
-    NS_IMETHOD
-    RegisterService(const char* aProgID, nsISupports* aService);
-
-    NS_IMETHOD
-    UnregisterService(const char* aProgID);
-
-    NS_IMETHOD
-    GetService(const char* aProgID, const nsIID& aIID,
-               nsISupports* *result,
-               nsIShutdownListener* shutdownListener = NULL);
-
-    NS_IMETHOD
-    ReleaseService(const char* aProgID, nsISupports* service,
-                   nsIShutdownListener* shutdownListener = NULL);
-
-    nsServiceManagerImpl(void);
-
-    NS_DECL_ISUPPORTS
-
-protected:
-
-    virtual ~nsServiceManagerImpl(void);
-
-    nsHashtable/*<nsServiceEntry>*/* mServices;
-};
-
-nsServiceManagerImpl::nsServiceManagerImpl(void)
-{
-    NS_INIT_REFCNT();
-    mServices = new nsHashtable(256, PR_TRUE);	// Get a threadSafe hashtable
-    NS_ASSERTION(mServices, "out of memory already?");
-}
-
-static PRBool
-DeleteEntry(nsHashKey *aKey, void *aData, void* closure)
-{
-    nsServiceEntry* entry = (nsServiceEntry*)aData;
-    NS_RELEASE(entry->mService);
-    delete entry;
-    return PR_TRUE;
-}
-
-nsServiceManagerImpl::~nsServiceManagerImpl(void)
-{
-    if (mServices) {
-        mServices->Enumerate(DeleteEntry);
-        delete mServices;
-    }
-}
-
-static NS_DEFINE_IID(kIServiceManagerIID, NS_ISERVICEMANAGER_IID);
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-
-NS_IMPL_ADDREF(nsServiceManagerImpl);
-NS_IMPL_RELEASE(nsServiceManagerImpl);
-
-NS_IMETHODIMP
-nsServiceManagerImpl::QueryInterface(const nsIID& aIID, void* *aInstancePtr)
-{
-    if (NULL == aInstancePtr) {
-        return NS_ERROR_NULL_POINTER; 
-    } 
-    *aInstancePtr = NULL; 
-    if (aIID.Equals(kIServiceManagerIID) ||
-        aIID.Equals(kISupportsIID)) {
-        *aInstancePtr = (void*) this; 
-        AddRef(); 
-        return NS_OK; 
-    } 
-    return NS_NOINTERFACE; 
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::GetService(const nsCID& aClass, const nsIID& aIID,
-                                 nsISupports* *result,
-                                 nsIShutdownListener* shutdownListener)
-{
-    nsresult rv = NS_OK;
-    /* XXX: This is a hack to force NSPR initialization..  This should be 
-     *      removed once PR_CEnterMonitor(...) initializes NSPR... (rick)
-     */
-    (void)PR_GetCurrentThread();
-    PR_CEnterMonitor(this);
-
-    nsIDKey key(aClass);
-    nsServiceEntry* entry = (nsServiceEntry*)mServices->Get(&key);
-
-    if (entry) {
-        nsISupports* service;
-        rv = entry->mService->QueryInterface(aIID, (void**)&service);
-        if (NS_SUCCEEDED(rv)) {
-            rv = entry->AddListener(shutdownListener);
-            if (NS_SUCCEEDED(rv)) {
-                *result = service;
-
-                // If someone else requested the service to be shut down, 
-                // and we just asked to get it again before it could be 
-                // released, then cancel their shutdown request:
-                if (entry->mShuttingDown) {
-                    entry->mShuttingDown = PR_FALSE;
-                    NS_ADDREF(service);      // Released in UnregisterService
-                }
-            }
-        }
-    }
-    else {
-        nsISupports* service;
-        rv = nsComponentManager::CreateInstance(aClass, NULL, aIID, (void**)&service);
-        if (NS_SUCCEEDED(rv)) {
-            entry = new nsServiceEntry(aClass, service);
-            if (entry == NULL) {
-                NS_RELEASE(service);
-                rv = NS_ERROR_OUT_OF_MEMORY;
-            }
-            else {
-                rv = entry->AddListener(shutdownListener);
-                if (NS_SUCCEEDED(rv)) {
-                    mServices->Put(&key, entry);
-                    *result = service;
-                    NS_ADDREF(service);      // Released in UnregisterService
-                }
-                else {
-                    NS_RELEASE(service);
-                    delete entry;
-                }
-            }
-        }
-    }
-
-    PR_CExitMonitor(this);
-    return rv;
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::ReleaseService(const nsCID& aClass, nsISupports* service,
-                                     nsIShutdownListener* shutdownListener)
-{
-    nsresult rv = NS_OK;
-    PR_CEnterMonitor(this);
-
-    nsIDKey key(aClass);
-    nsServiceEntry* entry = (nsServiceEntry*)mServices->Get(&key);
-
-    NS_ASSERTION(entry, "service not found");
-    // NS_ASSERTION(entry->mService == service, "service looked failed");
-
-    if (entry) {
-        rv = entry->RemoveListener(shutdownListener);
-        nsrefcnt cnt;
-        NS_RELEASE2(service, cnt);
-        if (NS_SUCCEEDED(rv) && cnt == 0) {
-            mServices->Remove(&key);
-            delete entry;
-            rv = nsComponentManager::FreeLibraries();
-        }
-    }
-
-    PR_CExitMonitor(this);
-    return rv;
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::RegisterService(const nsCID& aClass, nsISupports* aService)
-{
-    nsresult rv = NS_OK;
-    PR_CEnterMonitor(this);
-
-    nsIDKey key(aClass);
-    nsServiceEntry* entry = (nsServiceEntry*)mServices->Get(&key);
-    if (entry) {
-        rv = NS_ERROR_FAILURE;
-    }
-    else {
-        entry = new nsServiceEntry(aClass, aService);
-        if (entry == NULL) 
-            rv = NS_ERROR_OUT_OF_MEMORY;
-        else {
-            mServices->Put(&key, entry);
-            NS_ADDREF(aService);      // Released in UnregisterService
-        }
-    }
-    PR_CExitMonitor(this);
-    return rv;
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::UnregisterService(const nsCID& aClass)
-{
-    nsresult rv = NS_OK;
-    PR_CEnterMonitor(this);
-
-    nsIDKey key(aClass);
-    nsServiceEntry* entry = (nsServiceEntry*)mServices->Get(&key);
-
-    if (entry == NULL) {
-        rv = NS_ERROR_SERVICE_NOT_FOUND;
-    }
-    else {
-        rv = entry->NotifyListeners();         // break the cycles
-        entry->mShuttingDown = PR_TRUE;
-        nsrefcnt cnt;
-        NS_RELEASE2(entry->mService, cnt);       // AddRef in GetService
-        if (NS_SUCCEEDED(rv) && cnt == 0) {
-            mServices->Remove(&key);
-            delete entry;
-            rv = nsComponentManager::FreeLibraries();
-        }
-        else
-            rv = NS_ERROR_SERVICE_IN_USE;
-    }
-
-    PR_CExitMonitor(this);
-    return rv;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// let's do it again, this time with ProgIDs...
-
-NS_IMETHODIMP
-nsServiceManagerImpl::RegisterService(const char* aProgID, nsISupports* aService)
-{
-    nsCID aClass;
-    nsresult rv;
-    rv = nsComponentManager::ProgIDToCLSID(aProgID, &aClass);
-    if (NS_FAILED(rv)) return rv;
-    return RegisterService(aClass, aService);
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::UnregisterService(const char* aProgID)
-{
-    nsCID aClass;
-    nsresult rv;
-    rv = nsComponentManager::ProgIDToCLSID(aProgID, &aClass);
-    if (NS_FAILED(rv)) return rv;
-    return UnregisterService(aClass);
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::GetService(const char* aProgID, const nsIID& aIID,
-                                 nsISupports* *result,
-                                 nsIShutdownListener* shutdownListener)
-{
-    nsCID aClass;
-    nsresult rv;
-    rv = nsComponentManager::ProgIDToCLSID(aProgID, &aClass);
-    if (NS_FAILED(rv)) return rv;
-    return GetService(aClass, aIID, result, shutdownListener);
-}
-
-NS_IMETHODIMP
-nsServiceManagerImpl::ReleaseService(const char* aProgID, nsISupports* service,
-                                     nsIShutdownListener* shutdownListener)
-{
-    nsCID aClass;
-    nsresult rv;
-    rv = nsComponentManager::ProgIDToCLSID(aProgID, &aClass);
-    if (NS_FAILED(rv)) return rv;
-    return ReleaseService(aClass, service, shutdownListener);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-nsresult
-NS_NewServiceManager(nsIServiceManager* *result)
-{
-    nsServiceManagerImpl* servMgr = new nsServiceManagerImpl();
-    if (servMgr == NULL)
-        return NS_ERROR_OUT_OF_MEMORY;
-    NS_ADDREF(servMgr);
-    *result = servMgr;
-    return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Global service manager interface (see nsIServiceManager.h)
-
-nsresult
-nsServiceManager::GetGlobalServiceManager(nsIServiceManager* *result)
-{
-    nsresult rv = NS_OK;
-    if (mGlobalServiceManager == NULL) {
-        // XPCOM not initialized yet. Let us do initialization of our module.
-        rv = NS_InitXPCOM(NULL);
-    }
-    // No ADDREF as we are advicing no release of this.
-    if (NS_SUCCEEDED(rv)) *result = mGlobalServiceManager;
-
-    return rv;
-}
-
-nsresult
-nsServiceManager::ShutdownGlobalServiceManager(nsIServiceManager* *result)
-{
-    if (mGlobalServiceManager != NULL) {
-        NS_RELEASE(mGlobalServiceManager);
-        mGlobalServiceManager = NULL;
-    }
-    return NS_OK;
-}
-
-nsresult
-nsServiceManager::GetService(const nsCID& aClass, const nsIID& aIID,
-                             nsISupports* *result,
-                             nsIShutdownListener* shutdownListener)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->GetService(aClass, aIID, result, shutdownListener);
-}
-
-nsresult
-nsServiceManager::ReleaseService(const nsCID& aClass, nsISupports* service,
-                                 nsIShutdownListener* shutdownListener)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->ReleaseService(aClass, service, shutdownListener);
-}
-
-nsresult
-nsServiceManager::RegisterService(const nsCID& aClass, nsISupports* aService)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->RegisterService(aClass, aService);
-}
-
-nsresult
-nsServiceManager::UnregisterService(const nsCID& aClass)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->UnregisterService(aClass);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// let's do it again, this time with ProgIDs...
-
-nsresult
-nsServiceManager::GetService(const char* aProgID, const nsIID& aIID,
-                             nsISupports* *result,
-                             nsIShutdownListener* shutdownListener)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->GetService(aProgID, aIID, result, shutdownListener);
-}
-
-nsresult
-nsServiceManager::ReleaseService(const char* aProgID, nsISupports* service,
-                                 nsIShutdownListener* shutdownListener)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->ReleaseService(aProgID, service, shutdownListener);
-}
-
-nsresult
-nsServiceManager::RegisterService(const char* aProgID, nsISupports* aService)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->RegisterService(aProgID, aService);
-}
-
-nsresult
-nsServiceManager::UnregisterService(const char* aProgID)
-{
-    nsIServiceManager* mgr;
-    nsresult rv = GetGlobalServiceManager(&mgr);
-    if (NS_FAILED(rv)) return rv;
-    return mgr->UnregisterService(aProgID);
-}
-
-////////////////////////////////////////////////////////////////////////////////

mozilla/xpcom/components/nsXPComFactory.h

@@ -1,158 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License.  You may obtain a copy of the License at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the License is distributed on an "AS IS"
- * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
- * the License for the specific language governing rights and limitations
- * under the License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are Copyright (C) 1998
- * Netscape Communications Corporation.  All Rights Reserved.
- */
-
-#ifndef nsXPComFactory_h__
-#define nsXPComFactory_h__
-
-#include "nsIFactory.h"
-
-/*
- * This file contains a macro for the implementation of a simple XPCOM factory.
- *
- * To implement a factory for a given component, you need to declare the
- * factory class using the NS_DEF_FACTORY() macro.
- *
- * The first macro argument is the name for the factory.  
- * 
- * The second macro argument is a function (provided by you) which 
- * can be called by your DLL's NSGetFactory(...) entry point.
- *
- * Example:
- *
- *   NS_DEF_FACTORY(SomeComponent,SomeComponentImpl)
- *
- *   Declares:
- *   
- *     class nsSomeComponentFactory : public nsIFactory {};
- *
- * NOTE that the NS_DEF_FACTORY takes care of enforcing the "ns" prefix
- * and appending the "Factory" suffix to the given name.
- *
- *   To use the new factory:
- *
- *     nsresult NS_New_SomeComponent_Factory(nsIFactory** aResult)
- *     {
- *       nsresult rv = NS_OK;
- *       nsIFactory* inst = new nsSomeComponentFactory;
- *       if (NULL == inst) {
- *         rv = NS_ERROR_OUT_OF_MEMORY;
- *       } else {
- *         NS_ADDREF(inst);
- *       }
- *       *aResult = inst;
- *       return rv;
- *     }
- *
- * NOTE:
- * ----
- *  The factories created by this macro are not thread-safe and do not
- *  support aggregation.
- *
- */
-#define NS_DEF_FACTORY(_name,_type)                               \
-class ns##_name##Factory : public nsIFactory                      \
-{                                                                 \
-public:                                                           \
-  ns##_name##Factory() { NS_INIT_REFCNT(); }                      \
-                                                                  \
-  NS_IMETHOD_(nsrefcnt) AddRef (void)                             \
-  {                                                               \
-    return ++mRefCnt;                                             \
-  }                                                               \
-                                                                  \
-  NS_IMETHOD_(nsrefcnt) Release(void)                             \
-  {                                                               \
-    NS_PRECONDITION(0 != mRefCnt, "dup release");                 \
-    if (--mRefCnt == 0) {                                         \
-      NS_DELETEXPCOM(this);                                       \
-      return 0;                                                   \
-    }                                                             \
-    return mRefCnt;                                               \
-  }                                                               \
-                                                                  \
-  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr)   \
-  {                                                               \
-    if (NULL == aInstancePtr) {                                   \
-      return NS_ERROR_NULL_POINTER;                               \
-    }                                                             \
-                                                                  \
-    *aInstancePtr = NULL;                                         \
-                                                                  \
-    static NS_DEFINE_IID(kIFactoryIID,  NS_IFACTORY_IID);         \
-    static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);        \
-    if (aIID.Equals(kIFactoryIID)) {                              \
-      *aInstancePtr = (void*) this;                               \
-      NS_ADDREF_THIS();                                           \
-      return NS_OK;                                               \
-    }                                                             \
-    if (aIID.Equals(kISupportsIID)) {                             \
-      *aInstancePtr = (void*) ((nsISupports*)this);               \
-      NS_ADDREF_THIS();                                           \
-      return NS_OK;                                               \
-    }                                                             \
-    return NS_NOINTERFACE;                                        \
-  }                                                               \
-                                                                  \
-  NS_IMETHOD CreateInstance(nsISupports *aOuter,                  \
-                            const nsIID &aIID,                    \
-                            void **aResult)                       \
-  {                                                               \
-    nsresult rv;                                                  \
-                                                                  \
-    _type * inst;                                                 \
-                                                                  \
-    if (NULL == aResult) {                                        \
-      rv = NS_ERROR_NULL_POINTER;                                 \
-      goto done;                                                  \
-    }                                                             \
-    *aResult = NULL;                                              \
-    if (NULL != aOuter) {                                         \
-      rv = NS_ERROR_NO_AGGREGATION;                               \
-      goto done;                                                  \
-    }                                                             \
-                                                                  \
-    NS_NEWXPCOM(inst, _type);                                     \
-    if (NULL == inst) {                                           \
-      rv = NS_ERROR_OUT_OF_MEMORY;                                \
-      goto done;                                                  \
-    }                                                             \
-    NS_ADDREF(inst);                                              \
-    rv = inst->QueryInterface(aIID, aResult);                     \
-    NS_RELEASE(inst);                                             \
-                                                                  \
-  done:                                                           \
-    return rv;                                                    \
-  }                                                               \
-                                                                  \
-  NS_IMETHOD LockFactory(PRBool aLock)                            \
-  {                                                               \
-    return NS_OK;                                                 \
-  }                                                               \
-                                                                  \
-                                                                  \
-protected:                                                        \
-  virtual ~ns##_name##Factory()                                   \
-  {                                                               \
-    NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction"); \
-  }                                                               \
-                                                                  \
-  nsrefcnt mRefCnt;                                               \
-};
-
-#endif /* nsXPComFactory_h__ */

mozilla/xpcom/components/xcDll.cpp

@@ -1,273 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-/* nsDll
- *
- * Abstraction of a Dll. Stores modifiedTime and size for easy detection of
- * change in dll.
- *
- * dp Suresh <dp@netscape.com>
- */
-
-#include "xcDll.h"
-#include "plstr.h"	// strdup and strfree
-#include "nsIComponentManager.h"
-
-// MAC ONLY
-nsDll::nsDll(const char *codeDllName, int type)
-  : m_dllName(NULL), m_dllSpec(NULL), m_modDate(0), m_size(0),
-    m_instance(NULL), m_status(DLL_OK)
-    
-{
-    if (!codeDllName || !*codeDllName)
-    {
-        m_status = DLL_INVALID_PARAM;
-        return;
-    }
-    m_dllName = PL_strdup(codeDllName);
-    if (!m_dllName)
-    {
-        m_status = DLL_NO_MEM;
-        return;
-    }
-}
-
-nsDll::nsDll(nsIFileSpec *dllSpec)
-  : m_dllName(NULL), m_dllSpec(dllSpec), m_modDate(0), m_size(0),
-    m_instance(NULL), m_status(DLL_OK)
-{
-    Init(dllSpec);
-}
-
-nsDll::nsDll(const char *libPersistentDescriptor)
-  : m_dllName(NULL), m_dllSpec(NULL), m_modDate(0), m_size(0),
-    m_instance(NULL), m_status(DLL_OK)
-{
-    Init(libPersistentDescriptor);
-}
-
-nsDll::nsDll(const char *libPersistentDescriptor, PRUint32 modDate, PRUint32 fileSize)
-  : m_dllName(NULL), m_dllSpec(NULL), m_modDate(0), m_size(0),
-    m_instance(NULL), m_status(DLL_OK)
-{
-    Init(libPersistentDescriptor);
-
-    // and overwrite the modData and fileSize
-	m_modDate = modDate;
-	m_size = fileSize;
-}
- 
-void
-nsDll::Init(nsIFileSpec *dllSpec)
-{
-    // Addref the m_dllSpec
-    m_dllSpec = dllSpec;
-    NS_ADDREF(m_dllSpec);
-
-    // Make sure we are dealing with a file
-    PRBool isFile = PR_FALSE;
-    nsresult rv = m_dllSpec->isFile(&isFile);
-    if (NS_FAILED(rv))
-    {
-        m_status = DLL_INVALID_PARAM;
-        return;
-    }
-    if (isFile == PR_FALSE)
-    {
-      // Not a file. Cant work with it.
-      m_status = DLL_NOT_FILE;
-      return;
-    }
-    
-    // Populate m_modDate and m_size
-    if (NS_FAILED(m_dllSpec->GetModDate(&m_modDate)) ||
-        NS_FAILED(m_dllSpec->GetFileSize(&m_size)))
-    {
-        m_status = DLL_INVALID_PARAM;
-        return;
-    }
-
-	m_status = DLL_OK;			
-}
-
-void
-nsDll::Init(const char *libPersistentDescriptor)
-{
-    nsresult rv;
-    m_modDate = 0;
-	m_size = 0;
-	
-	if (libPersistentDescriptor == NULL)
-	{
-		m_status = DLL_INVALID_PARAM;
-		return;
-	}
-
-    // Create a FileSpec from the persistentDescriptor
-    nsIFileSpec *dllSpec = NULL;
-    NS_DEFINE_IID(kFileSpecIID, NS_IFILESPEC_IID);
-    rv = nsComponentManager::CreateInstance(NS_FILESPEC_PROGID, NULL, kFileSpecIID, (void **) &dllSpec);
-    if (NS_FAILED(rv))
-    {
-        m_status = DLL_INVALID_PARAM;
-        return;
-    }
-
-    rv = dllSpec->SetPersistentDescriptorString((char *)libPersistentDescriptor);
-    if (NS_FAILED(rv))
-    {
-        m_status = DLL_INVALID_PARAM;
-        return;
-    }
-
-    Init(dllSpec);
-}
-
-
-nsDll::~nsDll(void)
-{
-	if (m_instance != NULL)
-		Unload();
-    if (m_dllSpec)
-        NS_RELEASE(m_dllSpec);
-    if (m_dllName)
-        PL_strfree(m_dllName);
-}
-
-const char *
-nsDll::GetNativePath()
-{
-    if (m_dllName)
-        return m_dllName;
-    char *nativePath = NULL;
-    m_dllSpec->GetNativePath(&nativePath);
-    return nativePath;
-}
-
-const char *
-nsDll::GetPersistentDescriptorString()
-{
-    if (m_dllName)
-        return m_dllName;
-    char *persistentDescriptor = NULL;
-    m_dllSpec->GetPersistentDescriptorString(&persistentDescriptor);
-    return persistentDescriptor;
-}
-
-PRBool
-nsDll::HasChanged()
-{
-    if (m_dllName)
-        return PR_FALSE;
-
-    // If mod date has changed, then dll has changed
-    PRBool modDateChanged = PR_FALSE;
-    nsresult rv = m_dllSpec->modDateChanged(m_modDate, &modDateChanged);
-    if (NS_FAILED(rv) || modDateChanged == PR_TRUE)
-      return PR_TRUE;
-
-    // If size has changed, then dll has changed
-    PRUint32 aSize = 0;
-    rv = m_dllSpec->GetFileSize(&aSize);
-    if (NS_FAILED(rv) || aSize != m_size)
-      return PR_TRUE;
-
-    return PR_FALSE;
-}
-
-
-
-
-PRBool nsDll::Load(void)
-{
-	if (m_status != DLL_OK)
-	{
-		return (PR_FALSE);
-	}
-	if (m_instance != NULL)
-	{
-		// Already loaded
-		return (PR_TRUE);
-	}
-
-    if (m_dllName)
-    {
-        m_instance = PR_LoadLibrary(m_dllName);
-    }
-    else
-    {
-        char *nsprPath = NULL;
-        nsresult rv = m_dllSpec->GetNSPRPath(&nsprPath);
-        if (NS_FAILED(rv)) return PR_FALSE;
-
-#ifdef	XP_MAC
-        // NSPR path is / separated. This works for all NSPR functions
-        // except Load Library. Translate to something NSPR can accepts.
-        char *macFileName = PL_strdup(nsprPath);
-        if (macFileName != NULL)
-        {
-            if (macFileName[0] == '/')
-            {
-                // convert '/' to ':'
-                int c;
-                char* str = macFileName;
-                while ((c = *str++) != 0)
-                {
-                    if (c == '/')
-                        str[-1] = ':';
-                }
-                m_instance = PR_LoadLibrary(&macFileName[1]);		// skip over initial slash
-            }
-            else
-            {
-                m_instance = PR_LoadLibrary(macFileName);
-            }
-            PL_strfree(macFileName);
-        }
-#else
-        m_instance = PR_LoadLibrary(nsprPath);
-#endif /* XP_MAC */
-    }
-    return ((m_instance == NULL) ? PR_FALSE : PR_TRUE);
-}
-
-PRBool nsDll::Unload(void)
-{
-	if (m_status != DLL_OK || m_instance == NULL)
-		return (PR_FALSE);
-	PRStatus ret = PR_UnloadLibrary(m_instance);
-	if (ret == PR_SUCCESS)
-	{
-		m_instance = NULL;
-		return (PR_TRUE);
-	}
-	else
-		return (PR_FALSE);
-}
-
-void * nsDll::FindSymbol(const char *symbol)
-{
-	if (symbol == NULL)
-		return (NULL);
-	
-	// If not already loaded, load it now.
-	if (Load() != PR_TRUE)
-		return (NULL);
-
-	return (PR_FindSymbol(m_instance, symbol));
-}