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

@@ -0,0 +1,20 @@
+/* -*- 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 "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

@@ -0,0 +1,21 @@
+/* -*- 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 "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

@@ -0,0 +1,38 @@
+/* -*- 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_ASSIGNER_H_
+#define _REGISTER_ASSIGNER_H_
+
+#include "Fundamentals.h"
+#include "VirtualRegister.h"
+
+class FastBitMatrix;
+
+class RegisterAssigner
+{
+protected:
+  VirtualRegisterManager& vRegManager;
+  
+public:
+  RegisterAssigner(VirtualRegisterManager& vrMan) : vRegManager(vrMan) {}
+  
+  virtual bool assignRegisters(FastBitMatrix& interferenceMatrix) = 0;
+};
+
+#endif /* _REGISTER_ASSIGNER_H_ */

mozilla/ef/Compiler/RegisterAllocator/RegisterClass.h

@@ -0,0 +1,25 @@
+/* -*- 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_CLASS_H_
+#define _REGISTER_CLASS_H_
+
+#include "Fundamentals.h"
+#include "RegisterTypes.h"
+
+#endif // _REGISTER_CLASS_H_

mozilla/ef/Compiler/RegisterAllocator/RegisterPressure.h

@@ -0,0 +1,37 @@
+/* -*- 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_PRESSURE_H_
+#define _REGISTER_PRESSURE_H_
+
+#include "BitSet.h"
+#include "HashSet.h"
+
+struct LowRegisterPressure
+{
+	typedef BitSet Set;
+	static const bool setIsOrdered = true;
+};
+
+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

@@ -0,0 +1,32 @@
+/* -*- 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 "SSATools.h"
+#include "ControlGraph.h"
+#include "VirtualRegister.h"
+#include "Liveness.h"
+
+void replacePhiNodes(ControlGraph& controlGraph, VirtualRegisterManager& vrManager)
+{
+	if (!controlGraph.hasBackEdges)
+		return;
+
+	Liveness liveness(controlGraph.pool);
+	liveness.buildLivenessAnalysis(controlGraph, vrManager);
+}

mozilla/ef/Compiler/RegisterAllocator/SSATools.h

@@ -0,0 +1,29 @@
+/* -*- 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 _SSA_TOOLS_H_
+#define _SSA_TOOLS_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

@@ -0,0 +1,37 @@
+/* -*- 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 "SparseSet.h"
+#include "BitSet.h"
+#include "Pool.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

@@ -0,0 +1,40 @@
+/* -*- 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 "VirtualRegister.h"
+#include "Instruction.h"
+
+//------------------------------------------------------------------------------
+// VirtualRegister -
+
+#ifdef MANUAL_TEMPLATES
+template class IndexedPool<VirtualRegister>;
+#endif
+
+// Set the defining instruction.
+//
+void VirtualRegister::setDefiningInstruction(Instruction& instruction)
+{
+	if (definingInstruction != NULL) {
+		if ((instruction.getFlags() & ifCopy) && (definingInstruction->getFlags() & ifPhiNode))
+			return;
+	}
+	definingInstruction = &instruction;
+}
+

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/extensions/webservices/public/nsISOAPAttachments.idl

@@ -1,50 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-/**
- * This interface permits attachment of SOAP attachments.
- */
-
-[scriptable, uuid(6192dcbe-1dd2-11b2-81ad-a4597614c4ae)]
-interface nsISOAPAttachments : nsISupports {
-
-/**
- * Get the attachment associated with a particular identifier.
- *
- * @param aIdentifier The identifier of the attachment to be accessed.
- *
- * Appropriate return(s) must be identified.
- */
-void getAttachment(in AString aIdentifier);
-
-/**
- * Attach an attachment to the message.
- *
- * Appropriate argument(s) must be identified.
- *
- * @return The identifier of the attachment, to be referenced in SOAP encoding
- */
-AString attach();
-
-};

mozilla/extensions/webservices/public/nsISOAPCall.idl

@@ -1,90 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-#include "nsISOAPMessage.idl"
-
-interface nsISOAPResponse;
-interface nsISOAPResponseListener;
-
-/**
- * This interface is a convenience extension of the basic SOAP message,
- * which handles common patterns of calling, such as providing an
- * action URI in the HTTP header, locating and invoking the appropriate
- * transport based upon the protocol of the transportURI, and
- * automatically recieving the result in a new nsISOAPResponse object
- * which recieves an XML message.
- */
-
-[scriptable, uuid(a8fefe40-52bc-11d4-9a57-000064657374)]
-interface nsISOAPCall : nsISOAPMessage {
-
-  /**
-   * The URI to which the message will be sent, identifying the
-   *   transport and transport-specific information about the
-   *   destination.
-   * This does not have to match the <code>targetObjectURI</code>.
-   */
-  attribute AString transportURI;
-
-  /**
-   * Synchronously invoke the call. The method returns only when 
-   * we receive a response (or an error occurs).  The
-   * <code>transportURI</code> must have been set, the 
-   * parameter list (even if empty) must have been encoded,
-   * and the transportURI must use some known protocol.  A
-   * synchronous call assumes that there will be exactly one
-   * response per call.
-   *
-   * If not, an error is returned in the status of the response.
-   *
-   * @returns The SOAP response
-   */ 
-  nsISOAPResponse invoke();
-  
-  /**
-   * Asynchronously invoke the call. At this point, the document
-   * rooted by the Envelope element is encoded to form the body
-   * of the SOAP message. The method returns immediately, and the
-   * listener is invoked when we eventually receive a response
-   * (or error or successful completion). The
-   * <code>transportURI</code> must have been set, the 
-   * parameter list (even if empty) must have been encoded,
-   * and the transportURI must use some known protocol.
-   *
-   * If not, an error is returned in the status of the response.
-   *
-   * @param aListener Handler to be invoked asynchronously after the
-   *  response is recieved.  Should be null if no response is
-   *  expected.
-   */
-  void asyncInvoke(in nsISOAPResponseListener aListener);
-};
-
-%{ C++
-#define NS_SOAPCALL_CID                             \
-{ /* 87d21ec0-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec0, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPCALL_CONTRACTID \
-"@mozilla.org/xmlextras/soap/call;1"
-%}

mozilla/extensions/webservices/public/nsISOAPDecoder.idl

@@ -1,61 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISchemaType;
-interface nsISOAPEncoding;
-interface nsIDOMElement;
-interface nsIVariant;
-interface nsISOAPAttachments;
-
-/**
- * This interface supplies decoding of a specific
- * part of a message XML DOM into appropriate objects
- * for the script or application.
- */
-
-[scriptable, uuid(4c2e02ae-1dd2-11b2-b1cd-c79dea3d46db)]
-interface nsISOAPDecoder : nsISupports {
-
-/**
- * Decode the source DOM node
- *
- * @param aEncodings The encodings used to decode
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The DOM node to be decoded.
- *
- * @param aSchemaType The schema type of the source DOM node
- *
- * @param aAttachments Dispenses any attachments.
- *
- * @return The decoded variant, which is null if 
- *   the operation failed or did not return a result.
- */
-nsIVariant decode(
-    in nsISOAPEncoding aEncoding, 
-    in nsIDOMElement aSource, 
-    in nsISchemaType aSchemaType,
-    in nsISOAPAttachments aAttachments);
-};

mozilla/extensions/webservices/public/nsISOAPEncoder.idl

@@ -1,69 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISchemaType;
-interface nsISOAPEncoding;
-interface nsIVariant;
-interface nsIDOMElement;
-interface nsISOAPAttachments;
-
-/**
- * This interface permits encoding of variants.
- */
-
-[scriptable, uuid(fc33ffd6-1dd1-11b2-8750-fa62430a38b4)]
-interface nsISOAPEncoder : nsISupports {
-
-/**
- * Encode the source variant.
- *
- * @param aEncodings The encodings to be used.
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The variant to be encoded.
- *
- * @param aNamespaceURI The namespace of the thing being coded
- *
- * @param aName The name of the thing being coded
- *
- * @param aSchemaType The schema type of the thing being encoded
- *
- * @param aDestination The node scope, if any, where the result 
- *   will live.  If this is null, then the result must be 
- *   explicitly attached to the message.
- *
- * @return element which was inserted.
- *
- * @param aAttachments Accumulates any attachments.
- */
-nsIDOMElement encode(
-    in nsISOAPEncoding aEncoding, 
-    in nsIVariant aSource, 
-    in AString aNamespaceURI, 
-    in AString aName, 
-    in nsISchemaType aSchemaType,
-    in nsISOAPAttachments aAttachments,
-    in nsIDOMElement aDestination);
-};

mozilla/extensions/webservices/public/nsISOAPEncoding.idl

@@ -1,184 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISchemaType;
-interface nsIDOMElement;
-interface nsISOAPEncoder;
-interface nsISOAPDecoder;
-interface nsISOAPMessage;
-interface nsIVariant;
-interface nsISOAPAttachments;
-interface nsISchemaCollection;
-
-/**
- * This interface keeps track of all the known types and how
- *   each should be encoded (by type) or decoded (by 
- *   schema type)
- */
-
-[scriptable, uuid(9ae49600-1dd1-11b2-877f-e62f620c5e92)]
-interface nsISOAPEncoding : nsISupports {
-
-/**
- * The name of the encoding as it is known to SOAP.
- */
-  readonly attribute AString styleURI;
-
-/**
- * Get an alternative encoding.
- *
- * @param aStyleURI The style URI of the alternative encoding style.
- *
- * @param aCreateIf If true, then create the alternative style if it
- *   does not already exist, otherwise return the existing encoding.
- *
- * @return The alternative encoding which corresponds to the
- *   specified styleURI, or null if the spefied alternative encoding
- *   does not exist and it was not requested that it be created.
- */
-  nsISOAPEncoding getStyle(
-    in AString aStyleURI,
-    in boolean aCreateIf);
-
-/**
-  * Set an encoder in the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @param aEncoder The encoder to be specified or null to eliminate
-  *   the encoder.
-  *
-  * @return Old encoder registered under that type in the encoding, which
-  *   should be kept by the new encoder if it is to be called back.
-  */
-  void setEncoder(in AString aSchemaNamespaceURI, in AString aSchemaType, 
-   in nsISOAPEncoder aEncoder);
-
-/**
-  * Get an encoder from the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @return The encoder.
-  */
-  nsISOAPEncoder getEncoder(in AString aSchemaNamespaceURI, in AString aSchemaType);
-
-/**
-  * Set a decoder in the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @param aDecoder The decoder to be specified or null to eliminate
-  *   the decoder.
-  *
-  * @return Old decoder registered under that type in the encoding, which
-  *   should be kept by the new decoder if it is to be called back.
-  */
-  void setDecoder(in AString aSchemaNamespaceURI, in AString aSchemaType, 
-   in nsISOAPDecoder aDecoder);
-
-/**
-  * Get a decoder from the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @return The decoder.
-  */
-  nsISOAPDecoder getDecoder(in AString aSchemaNamespaceURI, in AString aSchemaType);
-
-  attribute nsISOAPEncoder defaultEncoder;
-
-  attribute nsISOAPDecoder defaultDecoder;
-
-  attribute nsISchemaCollection schemaCollection;
-
-/**
- * Encode the source variant
- *
- * @param aEncodings The encodings to be used.
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The variant to be encoded, soon to become a variant
- *
- * @param aNamespaceURI The namespace of the thing being coded
- *
- * @param aName The name of the thing being coded
- *
- * @param aSchemaType The schema type of the thing being encoded
- *
- * @param aDestination The node scope where the result will live.
- *
- * @param aAttachments Accumulates any attachments.
- *
- * @return The element which was inserted and encoded.
- */
-  nsIDOMElement encode(
-      in nsIVariant aSource, 
-      in AString aNamespaceURI,
-      in AString aName,
-      in nsISchemaType aSchemaType,
-      in nsISOAPAttachments aAttachments,
-      in nsIDOMElement aDestination);
-
-/**
- * Decode the source DOM node
- *
- * @param aEncodings The encodings used to decode
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The DOM node to be decoded.
- *
- * @param aSchemaType The schema type of the source DOM node
- *
- * @param aAttachments Dispenses any attachments.
- *
- * @return The decoded variant, soon to become a variant, which is null if 
- *   the operation failed or did not return a result.
- */
-  nsIVariant decode(
-      in nsIDOMElement aSource, 
-      in nsISchemaType aSchemaType,
-      in nsISOAPAttachments aAttachments);
-};
-
-%{ C++
-#define NS_DEFAULTSOAPENCODER_CID                            \
-{ /* 06fb035c-1dd2-11b2-bc30-f6d8e314d6b9 */        \
-  0x06fb035c, 0x1dd2, 0x11b2,                       \
- {0xbc, 0x30, 0xf6, 0xd8, 0xe3, 0x14, 0xd6, 0xb9} }
-#define NS_SOAPENCODING_CONTRACTID_PREFIX \
-"@mozilla.org/xmlextras/soap/encoding;1?uri="
-#define NS_DEFAULTSOAPENCODER_CONTRACTID \
-NS_SOAPENCODING_CONTRACTID_PREFIX "http://schemas.xmlsoap.org/soap/encoding/"
-%}

mozilla/extensions/webservices/public/nsISOAPFault.idl

@@ -1,69 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-
-/**
- * This interface conveniently interprets information about a fault 
- * that has been returned in a response message.
- *
- */
-
-[scriptable, uuid(99ec6694-535f-11d4-9a58-000064657374)]
-interface nsISOAPFault : nsISupports {
-  /**
-   * The DOM element representing the fault in the response SOAP message.
-   * This must be set for the rest of the interface to function correctly.
-   */
-  attribute nsIDOMElement element;
-
-  /**
-   * The fault code
-   */
-  readonly attribute AString faultCode;
-
-  /**
-   * The fault string
-   */
-  readonly attribute AString faultString;
-  
-  /**
-   * The fault actor if one was specified.
-   */
-  readonly attribute AString faultActor;
-
-  /**
-   * The DOM element representing the fault details
-   */
-  readonly attribute nsIDOMElement detail;
-};
-
-%{ C++
-#define NS_SOAPFAULT_CID                            \
-{ /* 87d21ec1-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec1, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPFAULT_CONTRACTID \
-"@mozilla.org/xmlextras/soap/fault;1"
-%}

mozilla/extensions/webservices/public/nsISOAPHeaderBlock.idl

@@ -1,96 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-interface nsIVariant;
-interface nsISOAPEncoding;
-interface nsISchemaType;
-interface nsISOAPAttachments;
-
-/**
- * This interface encapsulates an arbitrary header block to be used
- * by the soap serialization or protocol.  It formalizes a type
- * string, a reference to the object, and a name.
- */
-
-[scriptable, uuid(063d4a4e-1dd2-11b2-a365-cbaf1651f140)]
-interface nsISOAPHeaderBlock : nsISupports {
-    
-  /**
-   * The namespace URI of the header block.  Ignored if name is null.
-   */
-  attribute AString namespaceURI;
-    
-  /**
-   * The name of the header block. If the header block is left unnamed, it
-   * will be encoded using the element types defined in the SOAP-ENC
-   * schema. For example, <code>&lt;SOAP-ENC:int&gt;45&lt;/SOAP-ENC:int&gt;
-   * </code>
-   */
-  attribute AString name;
-
-  /**
-   * The actor URI of the header block.
-   */
-  attribute AString actorURI;
-
-  /**
-   * The encoding that was / will be applied to the
-   * header block.
-   */
-  attribute nsISOAPEncoding encoding;
-
-  /**
-   * The schema type used to encode or decode the
-   *   header block.
-   */
-  attribute nsISchemaType schemaType;
-
-  /**
-   *  The element which is the encoded value of this header block.
-   *  If this is set, value becomes a computed attribute
-   *  which is produced by decoding this element.
-   */
-  attribute nsIDOMElement element;
-
-  /**
-   *  The native value which is the decoded value of 
-   *  this header block.  If this is set, element becomes null.
-   */
-  attribute nsIVariant value;
-
-  /**
-   * The attachments which were attached to the message.
-   */
-  attribute nsISOAPAttachments attachments;
-};
-
-%{ C++
-#define NS_SOAPHEADERBLOCK_CID                        \
-{ /* 5ad0eace-1dd2-11b2-a260-ff42edcaedb3 */        \
-  0x5ad0eace, 0x1dd2, 0x11b2,                       \
- {0xa2, 0x60, 0xff, 0x42, 0xed, 0xca, 0xed, 0xb3} }
-#define NS_SOAPHEADERBLOCK_CONTRACTID \
-"@mozilla.org/xmlextras/soap/headerblock;1"
-%}

mozilla/extensions/webservices/public/nsISOAPMessage.idl

@@ -1,196 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMDocument;
-interface nsIDOMElement;
-interface nsISOAPEncoding;
-interface nsISOAPHeaderBlock;
-interface nsISOAPParameter;
-interface nsIVariant;
-
-/**
- * This interface controls all SOAP messages. It permits easy
- * construction of a message, typically through encoding of
- * parameters and certain properties settable on this interface
- * or through deserialization of a transport stream.  It
- * permits easy processing of a message typically through
- * decoding of parameters and certain properties available
- * on this interface.  It also encapsulates protocol information
- * interpreted by the transport.
- */
-
-[scriptable, uuid(3970815e-1dd2-11b2-a475-db4dac6826f1)]
-interface nsISOAPMessage : nsISupports {
-  /**
-   * The document which captures the message, if any.  A simple 
-   * sending application passes parameters to the method
-   * encodeSOAPParameters, which calls SOAP encoders 
-   * to construct this document along with all contained elements.  
-   *
-   * But an application may create and set the message directly
-   * instead of invoking encodeSOAPParameters to use encoders
-   * or access and manipulate the message after it has been 
-   * constructed by encodeSOAPParameters.  If the message has 
-   * not been set, invoking a call will fail.  A message reciever 
-   * may also use this accessor to get the document to avoid using 
-   * decoders.
-   */
-  attribute nsIDOMDocument message;
-
-  /**
-   * A convenience attribute to obtain the DOM element representing the
-   * SOAP envelope from the document.  DOM methods may be used to 
-   * access, add, or modify attributes of the envelope.
-   *
-   * If the message attribute is null or is not a document containing
-   * a root soap envelope element, then this will be null.
-   */
-  readonly attribute nsIDOMElement envelope;
-
-  /**
-   * A convenience attribute to obtain the DOM element representing the
-   * SOAP header from the envelope.  DOM methods may be used to 
-   * access, add, or modify attributes or elements of the header.
-   *
-   * If the envelope attribute is null or does not contain a SOAP header
-   * element type, then this will be null.
-   */
-  readonly attribute nsIDOMElement header;
-
-  /**
-   * A convenience attribute to obtain the DOM element representing the
-   * SOAP body from the envelope.  DOM methods may be used to 
-   * access, add, or modify attributes or elements of the body.
-   *
-   * If the envelope attribute is null or does not contain a SOAP body
-   * element type, then this will be null.
-   */
-  readonly attribute nsIDOMElement body;
-
-  /**
-   * The name of the method being invoked. The methodName is set
-   * during encoding as the tagname of the single child of body
-   * of RPC-style messages.  When there is no encoded message
-   * this will be null.  The value of this attribute for
-   * document-style messages may be non-null but should be
-   * ignored.  It is up to the application to know whether the
-   * message is RPC-style or document style because the SOAP
-   * specification makes it difficult to tell which way a
-   * message was encoded.
-   */
-  readonly attribute AString methodName;   
-
-  /**
-   * The target object on which the method is being invoked. This URI
-   * is set during encoding as the namespace to qualify the tagname 
-   * of the single child of body of RPC-style messages.  When there
-   * is no encoded message, this will be null.  The value of this
-   * attribute for document-style messages may be non-null but should
-   * be ignored.  It is up to the application to know whether the
-   * message is RPC-style or document style because the SOAP
-   * specification makes it difficult to tell which way a
-   * message was encoded.
-   */
-  readonly attribute AString targetObjectURI;
-
-  /**
-   * Encodes the specified parameters into this message, if
-   * this message type supports it.
-   *
-   * @param aMethodName The name of the method being invoked
-   * for rpc-style messages.  For document-style messages,
-   * this must be null.
-   *
-   * @param aTargetObjectURI The name of the target object
-   * for rpc-style messages.  For document-style messages,
-   * this must be null.
-   *
-   * @param aHeaderBlockCount Number of header blocks in array to be
-   *   encoded.  Must be 0 if header block array is null.
-   *
-   * @param aHeaderBlocks Array of header blocks to be encoded, which
-   *   may be null if there are no header blocks.
-   *
-   * @param aParameterCount Number of parameters in array 
-   *   to be encoded.  Must be 0 if parameter array is null.
-   *
-   * @param aParameters An array of parameters to be 
-   *   encoded, which may null if there are no parameters.
-   */
-  void encode(
-    in AString aMethodName, in AString aTargetObjectURI,
-    in PRUint32 aHeaderBlockCount, 
-    [array, size_is(aHeaderBlockCount)] in nsISOAPHeaderBlock aHeaderBlocks,
-    in PRUint32 aParameterCount, 
-    [array, size_is(aParameterCount)] in nsISOAPParameter aParameters);
-
-  /**
-   * Gathers the header blocks of a message so that they can be
-   *   accessed by a recipient.
-   *
-   * @param aCount Integer to receive the length of the list
-   *   of header blocks.
-   *
-   * @return Array of header blocks found in the message.
-   */
-  void getHeaderBlocks(out PRUint32 aCount,
-    [array, size_is(aCount), retval] out nsISOAPHeaderBlock aHeaderBlocks);
-
-  /**
-   * Gathers the parameters of a message so that they can be
-   *   accessed by a recipient.
-   *
-   * @param aDocumentStyle If true, then the parameters
-   *   are looked for treating the message as a document 
-   *   style message, otherwise it treated as an RPC-style 
-   *   message.
-   *
-   * @param aCount Integer to receive the length of the list
-   *   of parameters.
-   *
-   * @return Array of parameters found in the message.
-   */
-  void getParameters(in boolean aDocumentStyle,
-    out PRUint32 aCount, 
-    [array, size_is(aCount), retval] out nsISOAPParameter aParameters);
-
-  /**
-   * The primary encoding of the message, which is established
-   *   at the envelope and used unless overridden.  By default,
-   *   this is the SOAP encoding, which may be locally modified
-   *   or used to obtain alternative encodings, which may be
-   *   locally modified, but it may be set to an encoding that
-   *   is shared, or it may be set to null, in which case all
-   *   non-literal header blocks and parameters must specify an
-   *   encoding.
-   */
-  attribute nsISOAPEncoding encoding;
-
-  /**
-   * An optional URI that can be used to add a SOAPAction HTTP
-   * header field. If this attribute is NULL (the default case),
-   * no SOAPAction header will be added.
-   */
-  attribute AString actionURI;
-};

mozilla/extensions/webservices/public/nsISOAPParameter.idl

@@ -1,93 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-interface nsIVariant;
-interface nsISOAPEncoding;
-interface nsISchemaType;
-interface nsISOAPAttachments;
-
-/**
- * This interface encapsulates an arbitrary parameter to be used
- * by the soap serialization or protocol.  It formalizes a type
- * string, a reference to the object, and a name.
- */
-
-[scriptable, uuid(99ec6690-535f-11d4-9a58-000064657374)]
-interface nsISOAPParameter : nsISupports {
-    
-  /**
-   * The namespace URI of the parameter.  Ignored if name is null.
-   */
-  attribute AString namespaceURI;
-    
-  /**
-   * The name of the parameter. If the parameter is left unnamed, it
-   * will be encoded using the element types defined in the SOAP-ENC
-   * schema. For example, <code>&lt;SOAP-ENC:int&gt;45&lt;/SOAP-ENC:int&gt;
-   * </code>
-   */
-  attribute AString name;
-
-  /**
-   * The encoding that was / will be applied to the
-   * parameter.
-   */
-  attribute nsISOAPEncoding encoding;
-
-  /**
-   * The schema type used to encode or decode the
-   *   parameter.
-   */
-  attribute nsISchemaType schemaType;
-
-  /**
-   *  The element which is the encoded value of this parameter.
-   *  If this is set, value becomes a computed attribute
-   *  which may be produced by decoding this element.
-   */
-  attribute nsIDOMElement element;
-
-  /**
-   *  The native value which is the decoded value of 
-   *  this parameter.  If this is set, element becomes
-   *  null.
-   */
-  attribute nsIVariant value;
-
-  /**
-   * The attachments which were attached to the message
-   *   that may be needed to decode the parameter.
-   */
-  attribute nsISOAPAttachments attachments;
-};
-
-%{ C++
-#define NS_SOAPPARAMETER_CID                        \
-{ /* 87d21ec2-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec2, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPPARAMETER_CONTRACTID \
-"@mozilla.org/xmlextras/soap/parameter;1"
-%}

mozilla/extensions/webservices/public/nsISOAPResponse.idl

@@ -1,63 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-#include "nsISOAPCall.idl"
-
-interface nsISOAPParameter;
-interface nsISOAPFault;
-
-/**
- * This is an extension of a message which contains extra functions
- * such as tracking, where appropriate, the original call that
- * produced the response message, identifying the fault, if any,
- * and supplying the return value.
- */
-
-[scriptable, uuid(99ec6691-535f-11d4-9a58-000064657374)]
-interface nsISOAPResponse : nsISOAPMessage {
-  /**
-   * The message which generated this response.  There is no guarantee
-   *   that the message has not been modified since the original call
-   *   occurred.  This is set automatically when invoking a call that
-   *   returns this response.  This must also be set by a call processor
-   *   so that the transport can return a response to the correct caller.
-   */
-  attribute nsISOAPCall respondingTo;
-
-  /**
-   * The fault returned in the response, if one was generated. NULL
-   * if there was no fault.  This does not rely on the response
-   * parameters having been deserialized.
-   */
-  readonly attribute nsISOAPFault fault;
-
-};
-
-%{ C++
-#define NS_SOAPRESPONSE_CID                         \
-{ /* 87d21ec3-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec3, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPRESPONSE_CONTRACTID \
-"@mozilla.org/xmlextras/soap/response;1"
-%}

mozilla/extensions/webservices/public/nsISOAPResponseListener.idl

@@ -1,61 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISOAPCall;
-interface nsISOAPResponse;
-
-/**
- * This interface represents a response handler to be invoked whenever
- * a response of a particular call is recieved and when no more
- * responses are expected.
- */
-
-[scriptable, uuid(99ec6692-535f-11d4-9a58-000064657374)]
-interface nsISOAPResponseListener : nsISupports {
-  /**
-   * This method is invoked when we receive an asynchronous response to 
-   * a SOAP message. The listener is registered as part of the original
-   * asynchronous call invocation. 
-   *
-   * @param aResponse The decoded version of the response.  If an
-   *   error occurred transmitting the response, the status field
-   *   of the response will contain an error code.  The last call
-   *   to the listener may contain a null response, which should
-   *   only be interpreted as an error if your call expected more 
-   *   results than it got.  If the service or the transport
-   *   do not know whether to expect more results, then setting
-   *   the last parameter true may only be possible after the
-   *   last response has already been delivered.
-   *
-   * @param aLast True if this is the last call to the listener.
-   *
-   * @return True to make this the last call to the listener, even
-   *   if last was not true.  Calls which expect a single response
-   *   should return true upon receiving that response to avoid
-   *   possibly recieving another callback with a null response
-   *   indicating that the last response was already sent.
-   */ 
-  boolean handleResponse(in nsISOAPResponse aResponse, 
-    in nsISOAPCall aCall, in unsigned long status, in boolean aLast);
-};

mozilla/extensions/webservices/public/nsISOAPService.idl

@@ -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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISOAPMessage;
-interface nsISOAPResponseListener;
-
-/**
- * This interface describes a service which may be
- *   applied to incoming messages.  The service is
- *   responsible for determining whether the message
- *   is one that it should process and rejecting it
- *   if it is not.  Services may be chained.
- */
-[scriptable, uuid(9927fa40-1dd1-11b2-a8d1-857ad21b872c)]
-interface nsISOAPService : nsISupports {
-/**
- * Configuration object that may contain more info on the service
- */
-  attribute nsISupports configuration;
-
-/**
- * Process an incoming message.
- *
- * @param aMessage message to be processed
- *
- * @param aListener listener to which to report results
- *
- * @return True if the message will be handled, false if
- *   it should be given to some other service or fail.
- *   In case of failure, a more detailed status will be
- *   recorded in the message.
- */
-  boolean process(in nsISOAPMessage aMessage, 
-    in nsISOAPResponseListener aListener);
-};
-
-%{ C++
-#define NS_SOAPJSSERVICE_CID                            \
-{ /* 26a41df2-1dd2-11b2-9f29-909e637afa0e */        \
-  0x26a41df2, 0x1dd2, 0x11b2,                       \
- {0x9f, 0x29, 0x90, 0x9e, 0x63, 0x7a, 0xfa, 0x0e} }
-#define NS_SOAPJSSERVICE_CONTRACTID \
-"@mozilla.org/xmlextras/soap/jsservice;1"
-%}

mozilla/extensions/webservices/public/nsISOAPServiceRegistry.idl

@@ -1,93 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-interface nsISOAPService;
-interface nsISOAPEncodingRegistry;
-
-/**
- * This interface represents a registry of SOAP services.
- * This registry recieves transports to listen for messages
- *   and services to hand the messages to.  Service registries
- *   may be created as required.  Destroying a service registry
- *   stops the registry's action.  To temporarily register
- *   services, create a new registry.  For proper order of
- *   listening precedence, registries should be destroyed
- *   in reverse order.  Otherwise, a listening priority
- *   would be required.
- */
-[scriptable, uuid(9790d6bc-1dd1-11b2-afe0-bcb310c078bf)]
-interface nsISOAPServiceRegistry {
-/**
- * Process a configuration and add the resulting sources
- *   and services.  This will fail if errors occur during
- *   processing of the configuration.
- *
- * @param aConfiguration Root element of configuration XML.
- */
-  boolean addConfiguration(in nsIDOMElement aConfiguration);
-
-/**
- * Add a transport to be serviced by the registered services.
- *   This will fail if the specified source was already added
- *   with the same setting of the capture flag.
- *
- * @param aTransport string specifying the transport to supply
- *   messages for the service.
- *
- * @param aCapture True if capturing before later declarations
- */
-  void addSource(in AString aTransport, in boolean aCapture);
-
-/**
- * Add a service to service the registered transports.  This
- *   will fail if the specified service was already added.
- *
- * @param aService Service to be serviced.
- */
-  void addService(in nsISOAPService aService);
-
-/**
- * Registry identifying how to encode and decode
- *   messages containing specific types, automatically
- *   added to messages sent to services in this
- *   registry.
- */
-  attribute nsISOAPEncodingRegistry encodings;
-};
-
-%{ C++
-#define NS_SOAPSERVICEREGISTRY_CID                            \
-{ /* 3869184e-1dd2-11b2-aa36-d8333498043a */        \
-  0x3869184e, 0x1dd2, 0x11b2,                       \
- {0xaa, 0x36, 0xd8, 0x33, 0x34, 0x98, 0x04, 0x3a} }
-#define NS_SOAPSERVICEREGISTRY_CONTRACTID \
-"@mozilla.org/xmlextras/soap/serviceregistry;1"
-#define NS_SOAPDEFAULTSERVICEREGISTRY_CID                            \
-{ /* 9120a01e-1dd2-11b2-a61f-906766927a4f */        \
-  0x9120a01e, 0x1dd2, 0x11b2,                       \
- {0xa6, 0x1f, 0x90, 0x67, 0x66, 0x92, 0x7a, 0x4f} }
-#define NS_SOAPDEFAULTSERVICEREGISTRY_CONTRACTID \
-"@mozilla.org/xmlextras/soap/defaultserviceregistry;1"
-%}

mozilla/extensions/webservices/public/nsISOAPTransport.idl

@@ -1,102 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISOAPTransportListener;
-interface nsISOAPCall;
-interface nsISOAPResponse;
-interface nsISOAPResponseListener;
-
-[scriptable, uuid(99ec6695-535f-11d4-9a58-000064657374)]
-interface nsISOAPTransport : nsISupports {
-
-/**
- * Send the specified message to the specified destination.
- * This will fail if synchronous calls are not supported or if there is any
- * failure in the actual message exchange.  Failure of the call itself will be
- * contained in the response.
- *
- * @param aCall Actual message to be sent.
- *
- * @param aResponse Message to be recieved.  Calling synchronously assumes that 
- *   exactly one response is expected.
- */
-  void syncCall( in nsISOAPCall aCall,
-                 in nsISOAPResponse aResponse);
-
-/**
- * Send the specified message to the specified destination synchronously waiting 
- * for completion and any response.
- * This will fail if there is any failure in the setup of the message exchange.
- * Later errors will only be known through the response listener.  Failures of the
- * call itself will be contained in the response passed to the response listener.
- *
- * @param aCall Actual message to be sent.
- *
- * @param aListener Handler to be invoked (single threaded) as each response is 
- *  received and finally with null.  If specified as null, no responses are returned.
- *
- * @param response Message to recieve response and be handled by listener.  May be 
- *   null if listener is null.
- */
-  void asyncCall(in nsISOAPCall aCall,
-                 in nsISOAPResponseListener aListener,
-                 in nsISOAPResponse aResponse);
-
-/**
- * Add listener for unsolicited messages arriving on the transport.  Listeners
- *  are provided with the opportunity to accept and process messages.  Typically
- *  a listener will be a service dispatcher.  Listeners will be invoked in the
- *  reverse order of declaration, allowing more local service dispatchers to
- *  temporarily override permanent service dispatchers.  This will fail if the
- *  desired listener was already added to the transport with the specified
- *  capture flag or if the transport does not support incoming messages.
- *
- * @param aListener The listener to recieve unsolicited messages from the
- *   transport.
- *
- * @param aCapture True if the listener should capture the message before
- *   later-declared services.
- */
-  void addListener(in nsISOAPTransportListener aListener, in boolean aCapture);
-
-/**
- * Remove listener for unsolicited messages arriving on the transport.  This
- *  will fail if the specified listener was not added with the specified
- *  capture setting.
- *
- * @param aListener The listener to stop from recieving unsolicited messages 
- *  from the transport.
- *
- * @param aCapture True if the listener was added to capture the message before
- *   later-declared services (must be specified to remove, since a listener
- *   may be registered as both).
- */
-  void removeListener(in nsISOAPTransportListener aListener, in boolean aCapture);
-};
-
-%{ C++
-#define NS_SOAPTRANSPORT_CONTRACTID  \
-"@mozilla.org/xmlextras/soap/transport;1"
-#define NS_SOAPTRANSPORT_CONTRACTID_PREFIX   NS_SOAPTRANSPORT_CONTRACTID "?protocol="
-%}

mozilla/extensions/webservices/public/nsISOAPTransportListener.idl

@@ -1,50 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMDocument;
-interface nsISOAPMessage;
-
-/**
- * This interface recieves control when an unsolicited transport
- * is recieved on a transport.
- */
-
-[scriptable, uuid(99ec6696-535f-11d4-9a58-000064657374)]
-interface nsISOAPTransportListener : nsISupports {
-
-  /**
-   * This method is invoked when an unsolicited message is
-   *   recieved.  First all listeners are tried in the order declared
-   *   with the capture flag set.  Then all listeners are tried in
-   *   the reverse order declared with the capture flag clear.
-   *
-   * @param aMessage Actual message.
-   *
-   * @param aCapture True if the listener is being permitted to gain
-   *   control before all later-added listeners.
-   *
-   * @return true if message is handled, false if it was not
-   */
-  boolean handleMessage(in nsISOAPMessage aMessage, in boolean aCapture);
-};

mozilla/extensions/webservices/soap/Makefile.in

@@ -1,31 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS            = public src
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/webservices/soap/src/Makefile.in

@@ -1,52 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= xmlextras
-LIBRARY_NAME	= xmlextrassoap_s
-REQUIRES	= xpcom string caps dom js widget xpconnect necko schema
-
-CPPSRCS	= 				\
-		nsDefaultSOAPEncoder.cpp\
-		nsHTTPSOAPTransport.cpp	\
-		nsSOAPCall.cpp	        \
-		nsSOAPEncoding.cpp	\
-		nsSOAPFault.cpp	        \
-		nsSOAPHeaderBlock.cpp	\
-		nsSOAPMessage.cpp	\
-		nsSOAPParameter.cpp	\
-		nsSOAPResponse.cpp	\
-		nsSOAPUtils.cpp		\
-		$(NULL)
-
-# we don't want the shared lib, but we want to force the creation of a
-# static lib.
-FORCE_STATIC_LIB = 1
-#override NO_SHARED_LIB=1
-#override NO_STATIC_LIB=
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/webservices/soap/src/nsDefaultSOAPEncoder.h

@@ -1,34 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsDefaultSOAPEncoder_h__
-#define nsDefaultSOAPEncoder_h__
-
-#include "nsSOAPEncoding.h"
-
-class nsDefaultSOAPEncoder : public nsSOAPEncoding
-{
-public:
-  nsDefaultSOAPEncoder();
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsHTTPSOAPTransport.cpp

@@ -1,196 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsHTTPSOAPTransport.h"
-#include "nsIComponentManager.h"
-#include "nsIDOMDocument.h"
-#include "nsString.h"
-#include "nsSOAPUtils.h"
-#include "nsSOAPCall.h"
-#include "nsSOAPResponse.h"
-#include "nsIDOMEventTarget.h"
-
-nsHTTPSOAPTransport::nsHTTPSOAPTransport()
-{
-  NS_INIT_ISUPPORTS();
-}
-
-nsHTTPSOAPTransport::~nsHTTPSOAPTransport()
-{
-}
-
-NS_IMPL_ISUPPORTS1_CI(nsHTTPSOAPTransport, nsISOAPTransport)
-
-/* void syncCall (in nsISOAPCall aCall, in nsISOAPResponse aResponse); */
-NS_IMETHODIMP nsHTTPSOAPTransport::SyncCall(nsISOAPCall *aCall, nsISOAPResponse *aResponse)
-{
-  NS_ENSURE_ARG(aCall);
-
-  nsresult rv;
-  nsCOMPtr<nsIXMLHttpRequest> request;
-
-  request = do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  nsAutoString action;
-  rv = aCall->GetActionURI(action);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(action)) {
-    rv = request->SetRequestHeader("SOAPAction", NS_ConvertUCS2toUTF8(action).get());
-    if (NS_FAILED(rv)) return rv;
-  }
-
-  nsAutoString uri;
-  rv = aCall->GetTransportURI(uri);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(uri)) return NS_ERROR_NOT_INITIALIZED;
-
-  nsCOMPtr<nsIDOMDocument> messageDocument;
-  rv = aCall->GetMessage(getter_AddRefs(messageDocument));
-  if (NS_FAILED(rv)) return rv;
-  if (!messageDocument) return NS_ERROR_NOT_INITIALIZED;
-
-  rv = request->OpenRequest("POST", NS_ConvertUCS2toUTF8(uri).get(), PR_FALSE, nsnull, nsnull);
-  if (NS_FAILED(rv)) return rv;
-			    
-  rv = request->Send(messageDocument);
-  if (NS_FAILED(rv)) return rv;
-
-  request->GetStatus(&rv);
-  if (NS_FAILED(rv)) return rv;
-
-  if (aResponse) {
-    nsCOMPtr<nsIDOMDocument> response;
-    rv = request->GetResponseXML(getter_AddRefs(response));
-    if (NS_FAILED(rv)) return rv;
-    rv = aResponse->SetMessage(response);
-    if (NS_FAILED(rv)) return rv;
-  }
-
-  return NS_OK;
-}
-
-class nsHTTPSOAPTransportCompletion : public nsIDOMEventListener
-{
-public:
-  nsHTTPSOAPTransportCompletion();
-  virtual ~nsHTTPSOAPTransportCompletion();
-
-  NS_DECL_ISUPPORTS
-
-  // nsIDOMEventListener
-  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent);
-
-protected:
-  nsCOMPtr<nsISOAPCall> mCall;
-  nsCOMPtr<nsISOAPResponse> mResponse;
-  nsCOMPtr<nsIXMLHttpRequest> mRequest;
-  nsCOMPtr<nsISOAPResponseListener> mListener;
-};
-
-NS_IMPL_ISUPPORTS1(nsHTTPSOAPTransportCompletion, nsIDOMEventListener)
-
-nsHTTPSOAPTransportCompletion::nsHTTPSOAPTransportCompletion()
-{
-  NS_INIT_ISUPPORTS();
-}
-nsHTTPSOAPTransportCompletion::~nsHTTPSOAPTransportCompletion()
-{
-}
-NS_IMETHODIMP
-nsHTTPSOAPTransportCompletion::HandleEvent(nsIDOMEvent* aEvent)
-{
-  nsresult rv;
-  mRequest->GetStatus(&rv);
-  if (NS_SUCCEEDED(rv)) {
-    nsCOMPtr<nsIDOMDocument> document;
-    rv = mRequest->GetResponseXML(getter_AddRefs(document));
-    if (NS_SUCCEEDED(rv)) {
-      rv = mResponse->SetMessage(document);
-    }
-  }
-  PRBool c;  //  In other transports, this may signal to stop returning if multiple returns
-  mListener->HandleResponse(mResponse, mCall, (PRInt32)rv, PR_TRUE, &c);
-  return NS_OK;
-}
-
-/* void asyncCall (in nsISOAPCall aCall, in nsISOAPResponseListener aListener, in nsISOAPResponse aResponse); */
-NS_IMETHODIMP nsHTTPSOAPTransport::AsyncCall(nsISOAPCall *aCall, nsISOAPResponseListener *aListener, nsISOAPResponse *aResponse)
-{
-  NS_ENSURE_ARG(aCall);
-
-  nsresult rv;
-  nsCOMPtr<nsIXMLHttpRequest> request;
-
-  nsCOMPtr<nsIDOMEventTarget> eventTarget = do_QueryInterface(request, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  request = do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  nsAutoString action;
-  rv = aCall->GetActionURI(action);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(action)) {
-    rv = request->SetRequestHeader("SOAPAction", NS_ConvertUCS2toUTF8(action).get());
-    if (NS_FAILED(rv)) return rv;
-  }
-  nsCOMPtr<nsIDOMEventListener> listener = new nsHTTPSOAPTransportCompletion();
-  if (!listener) return NS_ERROR_OUT_OF_MEMORY;
-
-  nsAutoString uri;
-  rv = aCall->GetTransportURI(uri);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(uri)) return NS_ERROR_NOT_INITIALIZED;
-
-  nsCOMPtr<nsIDOMDocument> messageDocument;
-  rv = aCall->GetMessage(getter_AddRefs(messageDocument));
-  if (NS_FAILED(rv)) return rv;
-  if (!messageDocument) return NS_ERROR_NOT_INITIALIZED;
-
-  rv = request->OpenRequest("POST", NS_ConvertUCS2toUTF8(uri).get(), PR_TRUE, nsnull, nsnull);
-  if (NS_FAILED(rv)) return rv;
-			    
-  rv = request->Send(messageDocument);
-  if (NS_FAILED(rv)) return rv;
-
-  eventTarget->AddEventListener(NS_LITERAL_STRING("load"), listener, PR_FALSE);
-  eventTarget->AddEventListener(NS_LITERAL_STRING("error"), listener, PR_FALSE);
-  
-  rv = request->Send(messageDocument);
-  if (NS_FAILED(rv)) return rv;
-
-  return NS_OK;
-}
-
-/* void addListener (in nsISOAPTransportListener aListener, in boolean aCapture); */
-NS_IMETHODIMP nsHTTPSOAPTransport::AddListener(nsISOAPTransportListener *aListener, PRBool aCapture)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* void removeListener (in nsISOAPTransportListener aListener, in boolean aCapture); */
-NS_IMETHODIMP nsHTTPSOAPTransport::RemoveListener(nsISOAPTransportListener *aListener, PRBool aCapture)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-

mozilla/extensions/webservices/soap/src/nsHTTPSOAPTransport.h

@@ -1,50 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsHTTPSOAPTransport_h__
-#define nsHTTPSOAPTransport_h__
-
-#include "nsISOAPTransport.h"
-#include "nsIXMLHttpRequest.h"
-#include "nsIDOMEventListener.h"
-#include "nsISOAPTransportListener.h"
-#include "nsCOMPtr.h"
-
-class nsHTTPSOAPTransport : public nsISOAPTransport
-{
-public:
-  nsHTTPSOAPTransport();
-  virtual ~nsHTTPSOAPTransport();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPTransport
-  NS_DECL_NSISOAPTRANSPORT
-};
-
-#define NS_HTTPSOAPTRANSPORT_CID                   \
- { /* d852ade0-5823-11d4-9a62-00104bdf5339 */      \
- 0xd852ade0, 0x5823, 0x11d4,                       \
- {0x9a, 0x62, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_HTTPSOAPTRANSPORT_CONTRACTID NS_SOAPTRANSPORT_CONTRACTID_PREFIX "http"
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPCall.cpp

@@ -1,187 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsSOAPCall.h"
-#include "nsSOAPResponse.h"
-#include "nsSOAPUtils.h"
-#include "nsISOAPTransport.h"
-#include "nsIServiceManager.h"
-#include "nsIComponentManager.h"
-#include "nsIURI.h"
-#include "nsNetUtil.h"
-
-/////////////////////////////////////////////
-//
-//
-/////////////////////////////////////////////
-
-nsSOAPCall::nsSOAPCall()
-{
-}
-
-nsSOAPCall::~nsSOAPCall()
-{
-}
-
-NS_IMPL_CI_INTERFACE_GETTER2(nsSOAPCall, nsISOAPMessage, nsISOAPCall)
-NS_IMPL_ADDREF_INHERITED(nsSOAPCall, nsSOAPMessage)
-NS_IMPL_RELEASE_INHERITED(nsSOAPCall, nsSOAPMessage)
-
-NS_INTERFACE_MAP_BEGIN(nsSOAPCall)
-NS_INTERFACE_MAP_ENTRY(nsISOAPCall)
-NS_IMPL_QUERY_CLASSINFO(nsSOAPCall)
-NS_INTERFACE_MAP_END_INHERITING(nsSOAPMessage)
-
-/* attribute DOMString transportURI; */
-NS_IMETHODIMP nsSOAPCall::GetTransportURI(nsAWritableString & aTransportURI)
-{
-  NS_ENSURE_ARG_POINTER(&aTransportURI);
-  aTransportURI.Assign(mTransportURI);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPCall::SetTransportURI(const nsAReadableString & aTransportURI)
-{
-  mTransportURI.Assign(aTransportURI);
-  return NS_OK;
-}
-
-nsresult
-nsSOAPCall::GetTransport(nsISOAPTransport** aTransport)
-{
-  NS_ENSURE_ARG_POINTER(aTransport);
-  nsresult rv;
-  nsCOMPtr<nsIURI> uri;
-  nsXPIDLCString protocol;
-  nsCString transportURI(ToNewCString(mTransportURI));
-
-  rv = NS_NewURI(getter_AddRefs(uri), transportURI.get());
-  if (NS_FAILED(rv)) return rv;
-
-  uri->GetScheme(getter_Copies(protocol));
-  
-  nsCAutoString transportContractid;
-  transportContractid.Assign(NS_SOAPTRANSPORT_CONTRACTID_PREFIX);
-  transportContractid.Append(protocol);
-
-  nsCOMPtr<nsISOAPTransport> transport = do_GetService(transportContractid.get(), &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  *aTransport = transport.get();
-  NS_ADDREF(*aTransport);
-
-  return NS_OK;
-}
-
-/* nsISOAPResponse invoke (); */
-NS_IMETHODIMP nsSOAPCall::Invoke(nsISOAPResponse **_retval)
-{
-  NS_ENSURE_ARG_POINTER(_retval);
-  nsresult rv;
-  nsCOMPtr<nsISOAPTransport> transport;
-
-  if (mTransportURI.Length() == 0) {
-    return NS_ERROR_NOT_INITIALIZED;
-  }
-
-  rv = GetTransport(getter_AddRefs(transport));
-  if (NS_FAILED(rv)) return rv;
-  
-  nsCOMPtr<nsISOAPResponse> response;
-  response = new nsSOAPResponse();
-  if (!response) return NS_ERROR_OUT_OF_MEMORY;
-  rv = response->SetEncoding(mEncoding);
-  if (NS_FAILED(rv)) return rv;
-
-  rv = transport->SyncCall(this, response);
-  if (NS_FAILED(rv)) return rv;
-
-  return response->QueryInterface(NS_GET_IID(nsISOAPResponse), (void**)_retval);
-}
-
-/* void asyncInvoke (in nsISOAPResponseListener listener); */
-NS_IMETHODIMP nsSOAPCall::AsyncInvoke(nsISOAPResponseListener *listener)
-{
-  nsresult rv;
-  nsCOMPtr<nsISOAPTransport> transport;
-
-  if (mTransportURI.Length() == 0) {
-    return NS_ERROR_NOT_INITIALIZED;
-  }
-
-  rv = GetTransport(getter_AddRefs(transport));
-  if (NS_FAILED(rv)) return rv;
-  
-  nsCOMPtr<nsISOAPResponse> response;
-  response = new nsSOAPResponse();
-  if (!response) return NS_ERROR_OUT_OF_MEMORY;
-  rv = response->SetEncoding(mEncoding);
-  if (NS_FAILED(rv)) return rv;
-
-  rv = transport->AsyncCall(this, listener, response);
-  return rv;
-}
-
-static const char* kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPCall::CanCreateWrapper(const nsIID * iid, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPCall))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPCall::CanCallMethod(const nsIID * iid, const PRUnichar *methodName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPCall))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPCall::CanGetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPCall))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPCall::CanSetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPCall))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPCall.h

@@ -1,58 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPCall_h__
-#define nsSOAPCall_h__
-
-#include "nsString.h"
-#include "nsSOAPMessage.h"
-#include "nsISOAPCall.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsISOAPTransport.h"
-#include "nsISOAPResponseListener.h"
-#include "nsCOMPtr.h"
-
-class nsSOAPCall : public nsSOAPMessage,
-                   public nsISOAPCall
-{
-public:
-  nsSOAPCall();
-  virtual ~nsSOAPCall();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPCall
-  NS_FORWARD_NSISOAPMESSAGE(nsSOAPMessage::)
-
-  // nsISOAPCall
-  NS_DECL_NSISOAPCALL
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-protected:
-
-  nsString mTransportURI;
-  nsresult GetTransport(nsISOAPTransport** aTransport);
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPEncoding.cpp

@@ -1,405 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsString.h"
-#include "nsISOAPParameter.h"
-#include "nsSOAPMessage.h"
-#include "nsISOAPEncoder.h"
-#include "nsISOAPDecoder.h"
-#include "nsSOAPEncoding.h"
-#include "nsSOAPUtils.h"
-#include "nsIServiceManager.h"
-#include "nsIComponentManager.h"
-#include "nsIDOMNodeList.h"
-#include "nsISchema.h"
-#include "nsISchemaLoader.h"
-#include "nsSOAPUtils.h"
-
-//  First comes the registry which shares between associated encodings but is never seen by xpconnect.
-
-NS_IMPL_ISUPPORTS1(nsSOAPEncodingRegistry,nsISOAPEncoding)
-
-nsSOAPEncodingRegistry::nsSOAPEncodingRegistry(nsISOAPEncoding* aEncoding): mEncodings(new nsSupportsHashtable) 
-{
-  NS_INIT_ISUPPORTS();
-
-  nsAutoString style;
-  aEncoding->GetStyleURI(style);
-  nsStringKey styleKey(style);
-  mEncodings->Put(&styleKey, aEncoding);
-  /* member initializers and constructor code */
-}
-
-nsSOAPEncodingRegistry::~nsSOAPEncodingRegistry()
-{
-  /* destructor code */
-  delete mEncodings;
-}
-
-nsresult nsSOAPEncodingRegistry::GetStyle(const nsAString& aStyleURI, PRBool aCreateIf, nsISOAPEncoding* * aEncoding)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aStyleURI);
-  NS_ENSURE_ARG_POINTER(aEncoding);
-  nsStringKey styleKey(aStyleURI);
-  *aEncoding = (nsISOAPEncoding*)mEncodings->Get(&styleKey);
-  if (!*aEncoding)
-  {
-    nsCOMPtr<nsISOAPEncoding> defaultEncoding;
-    nsCAutoString encodingContractid;
-    encodingContractid.Assign(NS_SOAPENCODING_CONTRACTID_PREFIX);
-    encodingContractid.Append(NS_ConvertUCS2toUTF8(aStyleURI));
-    defaultEncoding = do_GetService(encodingContractid.get());
-    if (defaultEncoding || aCreateIf) {
-      *aEncoding = new nsSOAPEncoding(aStyleURI, this, defaultEncoding);
-      mEncodings->Put(&styleKey, *aEncoding);
-    }
-  }
-  return NS_OK;
-}
-nsresult nsSOAPEncodingRegistry::SetSchemaCollection(nsISchemaCollection* aSchemaCollection)
-{
-  NS_ENSURE_ARG(aSchemaCollection);
-  mSchemaCollection = aSchemaCollection;
-  return NS_OK;
-}
-nsresult nsSOAPEncodingRegistry::GetSchemaCollection(nsISchemaCollection** aSchemaCollection)
-{
-  NS_ENSURE_ARG_POINTER(aSchemaCollection);
-  if (!mSchemaCollection) {
-    nsresult rv;
-    nsCOMPtr<nsISchemaLoader>loader = do_CreateInstance(NS_SCHEMALOADER_CONTRACTID, &rv);
-    if (NS_FAILED(rv)) return rv;
-    mSchemaCollection = do_QueryInterface(loader);
-    if (!mSchemaCollection) return NS_ERROR_FAILURE;
-  }
-  *aSchemaCollection = mSchemaCollection;
-  NS_ADDREF(*aSchemaCollection);
-  return NS_OK;
-}
-
-/* readonly attribute AString styleURI; */
-NS_IMETHODIMP nsSOAPEncodingRegistry::GetStyleURI(nsAString & aStyleURI)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsISOAPEncoder setEncoder (in AString aSchemaNamespaceURI, in AString aSchemaType, in nsISOAPEncoder aEncoder); */
-NS_IMETHODIMP nsSOAPEncodingRegistry::SetEncoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPEncoder *aEncoder)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsISOAPEncoder getEncoder (in AString aSchemaNamespaceURI, in AString aSchemaType); */
-NS_IMETHODIMP nsSOAPEncodingRegistry::GetEncoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPEncoder **_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsISOAPDecoder setDecoder (in AString aSchemaNamespaceURI, in AString aSchemaType, in nsISOAPDecoder aDecoder); */
-NS_IMETHODIMP nsSOAPEncodingRegistry::SetDecoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPDecoder *aDecoder)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsISOAPDecoder getDecoder (in AString aSchemaNamespaceURI, in AString aSchemaType); */
-NS_IMETHODIMP nsSOAPEncodingRegistry::GetDecoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPDecoder **_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* attribute nsISOAPEncoder defaultEncoder; */
-NS_IMETHODIMP nsSOAPEncodingRegistry::GetDefaultEncoder(nsISOAPEncoder * *aDefaultEncoder)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-NS_IMETHODIMP nsSOAPEncodingRegistry::SetDefaultEncoder(nsISOAPEncoder * aDefaultEncoder)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* attribute nsISOAPDecoder defaultDecoder; */
-NS_IMETHODIMP nsSOAPEncodingRegistry::GetDefaultDecoder(nsISOAPDecoder * *aDefaultDecoder)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-NS_IMETHODIMP nsSOAPEncodingRegistry::SetDefaultDecoder(nsISOAPDecoder * aDefaultDecoder)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsIDOMElement encode (in nsIVariant aSource, in AString aNamespaceURI, in AString aName, in nsISchemaType aSchemaType, in nsISOAPAttachments aAttachments, in nsIDOMElement aDestination); */
-NS_IMETHODIMP nsSOAPEncodingRegistry::Encode(nsIVariant *aSource, const nsAString & aNamespaceURI, const nsAString & aName, nsISchemaType *aSchemaType, nsISOAPAttachments *aAttachments, nsIDOMElement *aDestination, nsIDOMElement **_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsIVariant decode (in nsIDOMElement aSource, in nsISchemaType aSchemaType, in nsISOAPAttachments aAttachments); */
-NS_IMETHODIMP nsSOAPEncodingRegistry::Decode(nsIDOMElement *aSource, nsISchemaType *aSchemaType, nsISOAPAttachments *aAttachments, nsIVariant **_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-//  Second, we create the encodings themselves.
-
-NS_IMPL_ISUPPORTS2(nsSOAPEncoding, nsISOAPEncoding, nsISecurityCheckedComponent)
-
-nsSOAPEncoding::nsSOAPEncoding(): mEncoders(new nsSupportsHashtable),
-  mDecoders(new nsSupportsHashtable)
-{
-  NS_INIT_ISUPPORTS();
-
-  /* member initializers and constructor code */
-
-  mStyleURI.Assign(nsSOAPUtils::kSOAPEncodingURI);
-  mDefaultEncoding = do_GetService(NS_DEFAULTSOAPENCODER_CONTRACTID);
-  mRegistry = new nsSOAPEncodingRegistry(this);
-}
-
-nsSOAPEncoding::nsSOAPEncoding(const nsAString& aStyleURI, nsSOAPEncodingRegistry* aRegistry, nsISOAPEncoding* aDefaultEncoding)
-	: mEncoders(new nsSupportsHashtable), mDecoders(new nsSupportsHashtable)
-{
-  NS_INIT_ISUPPORTS();
-
-  /* member initializers and constructor code */
-
-  mStyleURI.Assign(aStyleURI);
-  mRegistry = aRegistry;
-  mDefaultEncoding = aDefaultEncoding;
-}
-
-nsSOAPEncoding::~nsSOAPEncoding()
-{
-  /* destructor code */
-  delete mEncoders;
-  delete mDecoders;
-}
-
-nsresult nsSOAPEncoding::SetSchemaCollection(nsISchemaCollection* aSchemaCollection)
-{
-  NS_ENSURE_ARG(aSchemaCollection);
-  return mRegistry->SetSchemaCollection(aSchemaCollection);
-}
-nsresult nsSOAPEncoding::GetSchemaCollection(nsISchemaCollection** aSchemaCollection)
-{
-  NS_ENSURE_ARG_POINTER(aSchemaCollection);
-  return mRegistry->GetSchemaCollection(aSchemaCollection);
-}
-
-/* readonly attribute AString styleURI; */
-NS_IMETHODIMP nsSOAPEncoding::GetStyleURI(nsAString & aStyleURI)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aStyleURI);
-  aStyleURI.Assign(mStyleURI);
-  return NS_OK;
-}
-
-/* nsISOAPEncoding getStyle (in AString aStyleURI, in boolean aCreateIf); */
-NS_IMETHODIMP nsSOAPEncoding::GetStyle(const nsAString & aStyleURI, PRBool aCreateIf, nsISOAPEncoding **_retval)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aStyleURI);
-  NS_ENSURE_ARG_POINTER(_retval);
-  return mRegistry->GetStyle(aStyleURI, aCreateIf, _retval);
-}
-
-/* nsISOAPEncoder setEncoder (in AString aSchemaNamespaceURI, in AString aSchemaType, in nsISOAPEncoder aEncoder); */
-NS_IMETHODIMP nsSOAPEncoding::SetEncoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPEncoder *aEncoder)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaNamespaceURI);
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaType);
-  NS_ENSURE_ARG(aEncoder);
-  nsAutoString name(aSchemaNamespaceURI);
-  name.Append(nsSOAPUtils::kEncodingSeparator);
-  name.Append(aSchemaType);
-  nsStringKey nameKey(name);
-  if (aEncoder) {
-    mEncoders->Put(&nameKey, aEncoder, nsnull);
-  }
-  else {
-    mEncoders->Remove(&nameKey, nsnull);
-  }
-  return NS_OK;
-}
-
-/* nsISOAPEncoder getEncoder (in AString aSchemaNamespaceURI, in AString aSchemaType); */
-NS_IMETHODIMP nsSOAPEncoding::GetEncoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPEncoder **_retval)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaNamespaceURI);
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaType);
-  NS_ENSURE_ARG_POINTER(_retval);
-  nsAutoString name(aSchemaNamespaceURI);
-  name.Append(nsSOAPUtils::kEncodingSeparator);
-  name.Append(aSchemaType);
-  nsStringKey nameKey(name);
-  *_retval = (nsISOAPEncoder*)mEncoders->Get(&nameKey);
-  if (*_retval == nsnull && mDefaultEncoding != nsnull) {
-    return mDefaultEncoding->GetEncoder(aSchemaNamespaceURI, aSchemaType, _retval);
-  }
-  return NS_OK;
-}
-
-/* nsISOAPDecoder setDecoder (in AString aSchemaNamespaceURI, in AString aSchemaType, in nsISOAPDecoder aDecoder); */
-NS_IMETHODIMP nsSOAPEncoding::SetDecoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPDecoder *aDecoder)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaNamespaceURI);
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaType);
-  nsAutoString name(aSchemaNamespaceURI);
-  name.Append(nsSOAPUtils::kEncodingSeparator);
-  name.Append(aSchemaType);
-  nsStringKey nameKey(name);
-  if (aDecoder) {
-    mDecoders->Put(&nameKey, aDecoder, nsnull);
-  }
-  else {
-    mDecoders->Remove(&nameKey, nsnull);
-  }
-  return NS_OK;
-}
-
-/* nsISOAPDecoder getDecoder (in AString aSchemaNamespaceURI, in AString aSchemaType); */
-NS_IMETHODIMP nsSOAPEncoding::GetDecoder(const nsAString & aSchemaNamespaceURI, const nsAString & aSchemaType, nsISOAPDecoder **_retval)
-{
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaNamespaceURI);
-  NS_SOAP_ENSURE_ARG_STRING(aSchemaType);
-  NS_ENSURE_ARG_POINTER(_retval);
-  nsAutoString name(aSchemaNamespaceURI);
-  name.Append(nsSOAPUtils::kEncodingSeparator);
-  name.Append(aSchemaType);
-  nsStringKey nameKey(name);
-  *_retval = (nsISOAPDecoder*)mDecoders->Get(&nameKey);
-  if (*_retval == nsnull && mDefaultEncoding != nsnull) {
-    return mDefaultEncoding->GetDecoder(aSchemaNamespaceURI, aSchemaType, _retval);
-  }
-  return NS_OK;
-}
-
-/* nsIDOMElement encode (in nsIVariant aSource, in AString aNamespaceURI, in AString aName, in nsISchemaType aSchemaType, in nsISOAPAttachments aAttachments, in nsIDOMElement aDestination); */
-NS_IMETHODIMP nsSOAPEncoding::Encode(nsIVariant *aSource, const nsAString & aNamespaceURI, const nsAString & aName, nsISchemaType *aSchemaType, nsISOAPAttachments *aAttachments, nsIDOMElement *aDestination, nsIDOMElement **_retval)
-{
-  NS_ENSURE_ARG(aSource);
-  NS_ENSURE_ARG_POINTER(_retval);
-
-  nsCOMPtr<nsISOAPEncoder> encoder;
-  nsresult rv = GetDefaultEncoder(getter_AddRefs(encoder));
-  if (NS_FAILED(rv)) return rv;
-  if (encoder) {
-    return encoder->Encode(this, aSource, aNamespaceURI, aName, aSchemaType, aAttachments, aDestination,
-		    _retval);
-  }
-  *_retval = nsnull;
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* nsIVariant decode (in nsIDOMElement aSource, in nsISchemaType aSchemaType, in nsISOAPAttachments aAttachments); */
-NS_IMETHODIMP nsSOAPEncoding::Decode(nsIDOMElement *aSource, nsISchemaType *aSchemaType, nsISOAPAttachments *aAttachments, nsIVariant **_retval)
-{
-  NS_ENSURE_ARG(aSource);
-  NS_ENSURE_ARG_POINTER(_retval);
-  nsCOMPtr<nsISOAPDecoder> decoder;
-  nsresult rv = GetDefaultDecoder(getter_AddRefs(decoder));
-  if (NS_FAILED(rv)) return rv;
-  if (decoder) {
-    return decoder->Decode(this, aSource, aSchemaType, aAttachments, _retval);
-  }
-  *_retval = nsnull;
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* attribute nsISOAPEncoder defaultEncoder; */
-NS_IMETHODIMP nsSOAPEncoding::GetDefaultEncoder(nsISOAPEncoder * *aDefaultEncoder)
-{
-  NS_ENSURE_ARG_POINTER(aDefaultEncoder);
-  if (mDefaultEncoding && !mDefaultEncoder) {
-    return mDefaultEncoding->GetDefaultEncoder(aDefaultEncoder);
-  }
-  *aDefaultEncoder = mDefaultEncoder;
-  NS_IF_ADDREF(*aDefaultEncoder);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPEncoding::SetDefaultEncoder(nsISOAPEncoder * aDefaultEncoder)
-{
-  mDefaultEncoder = aDefaultEncoder;
-  return NS_OK;
-}
-
-/* attribute nsISOAPDecoder defaultDecoder; */
-NS_IMETHODIMP nsSOAPEncoding::GetDefaultDecoder(nsISOAPDecoder * *aDefaultDecoder)
-{
-  NS_ENSURE_ARG_POINTER(aDefaultDecoder);
-  if (mDefaultEncoding && !mDefaultDecoder) {
-    return mDefaultEncoding->GetDefaultDecoder(aDefaultDecoder);
-  }
-  *aDefaultDecoder = mDefaultDecoder;
-  NS_IF_ADDREF(*aDefaultDecoder);
-  return NS_OK;
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-NS_IMETHODIMP nsSOAPEncoding::SetDefaultDecoder(nsISOAPDecoder * aDefaultDecoder)
-{
-  mDefaultDecoder = aDefaultDecoder;
-  return NS_OK;
-}
-
-static const char* kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPEncoding::CanCreateWrapper(const nsIID * iid, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPEncoding))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPEncoding::CanCallMethod(const nsIID * iid, const PRUnichar *methodName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPEncoding))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPEncoding::CanGetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPEncoding))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPEncoding::CanSetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPEncoding))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPEncoding.h

@@ -1,77 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPEncodingRegistry_h__
-#define nsSOAPEncodingRegistry_h__
-
-#include "nsString.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsIDOMElement.h"
-#include "nsISOAPEncoding.h"
-#include "nsISOAPEncoder.h"
-#include "nsISOAPDecoder.h"
-#include "nsCOMPtr.h"
-#include "nsHashtable.h"
-#include "nsISchema.h"
-
-class nsSOAPEncoding;
-
-/* Header file */
-class nsSOAPEncodingRegistry : public nsISOAPEncoding
-{
-public:
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSISOAPENCODING
-  nsSOAPEncodingRegistry() {}
-  nsSOAPEncodingRegistry(nsISOAPEncoding* aEncoding);
-  virtual ~nsSOAPEncodingRegistry();
-protected:
-  nsSupportsHashtable* mEncodings;
-  nsCOMPtr<nsISchemaCollection> mSchemaCollection;
-};
-
-class nsSOAPEncoding : public nsISOAPEncoding,
-		    public nsISecurityCheckedComponent
-{
-public:
-  NS_DECL_ISUPPORTS
-
-  NS_DECL_NSISOAPENCODING
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-  nsSOAPEncoding();
-  nsSOAPEncoding(const nsAString& aStyleURI, nsSOAPEncodingRegistry * aRegistry, nsISOAPEncoding* aDefaultEncoding);
-  virtual ~nsSOAPEncoding();
-  /* additional members */
-
-protected:
-  nsString mStyleURI;
-  nsSupportsHashtable* mEncoders;
-  nsSupportsHashtable* mDecoders;
-  nsCOMPtr<nsISOAPEncoding> mRegistry;
-  nsCOMPtr<nsISOAPEncoding> mDefaultEncoding;
-  nsCOMPtr<nsISOAPEncoder> mDefaultEncoder;
-  nsCOMPtr<nsISOAPDecoder> mDefaultDecoder;
-};
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPFault.cpp

@@ -1,154 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsSOAPFault.h"
-#include "nsSOAPUtils.h"
-#include "nsIDOMNodeList.h"
-
-nsSOAPFault::nsSOAPFault(nsIDOMElement* aElement)
-{
-  NS_INIT_ISUPPORTS();
-  mFaultElement = aElement;
-}
-
-nsSOAPFault::~nsSOAPFault()
-{
-}
-
-NS_IMPL_ISUPPORTS2(nsSOAPFault, nsISOAPFault, nsISecurityCheckedComponent)
-
-/* attribute nsIDOMElement element; */
-NS_IMETHODIMP nsSOAPFault::SetElement(nsIDOMElement *aElement)
-{
-  mFaultElement = aElement;
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPFault::GetElement(nsIDOMElement * *aElement)
-{
-  NS_ENSURE_ARG_POINTER(aElement);
-  *aElement = mFaultElement;
-  NS_IF_ADDREF(*aElement);
-  return NS_OK;
-}
-
-/* readonly attribute wstring faultCode; */
-NS_IMETHODIMP nsSOAPFault::GetFaultCode(nsAWritableString & aFaultCode)
-{
-  NS_ENSURE_ARG_POINTER(&aFaultCode);
-  aFaultCode.Truncate();
-  nsCOMPtr<nsIDOMElement> faultcode;
-  nsSOAPUtils::GetSpecificChildElement(mFaultElement, 
-                                       nsSOAPUtils::kSOAPEnvURI, 
-                                       nsSOAPUtils::kFaultCodeTagName, 
-                                       getter_AddRefs(faultcode));
-  if (faultcode) {
-    nsSOAPUtils::GetElementTextContent(faultcode, aFaultCode);
-  }
-  return NS_OK;
-}
-
-/* readonly attribute wstring faultString; */
-NS_IMETHODIMP nsSOAPFault::GetFaultString(nsAWritableString & aFaultString)
-{
-  NS_ENSURE_ARG_POINTER(&aFaultString);
-
-  aFaultString.Truncate();
-  nsCOMPtr<nsIDOMElement> element;
-  nsSOAPUtils::GetSpecificChildElement(mFaultElement, nsSOAPUtils::kSOAPEnvURI,
-    nsSOAPUtils::kFaultStringTagName, getter_AddRefs(element));
-  if (element) {
-    nsSOAPUtils::GetElementTextContent(element, aFaultString);
-  }
-  return NS_OK;
-}
-
-/* readonly attribute wstring faultActor; */
-NS_IMETHODIMP nsSOAPFault::GetFaultActor(nsAWritableString & aFaultActor)
-{
-  NS_ENSURE_ARG_POINTER(&aFaultActor);
-
-  aFaultActor.Truncate();
-  nsCOMPtr<nsIDOMElement> element;
-  nsSOAPUtils::GetSpecificChildElement(mFaultElement, nsSOAPUtils::kSOAPEnvURI,
-    nsSOAPUtils::kFaultActorTagName, getter_AddRefs(element));
-  if (element) {
-    nsSOAPUtils::GetElementTextContent(element, aFaultActor);
-  }
-  return NS_OK;
-}
-
-/* readonly attribute nsIDOMElement detail; */
-NS_IMETHODIMP nsSOAPFault::GetDetail(nsIDOMElement * *aDetail)
-{
-  NS_ENSURE_ARG_POINTER(aDetail);
-
-  nsCOMPtr<nsIDOMElement> element;
-  nsSOAPUtils::GetSpecificChildElement(mFaultElement, nsSOAPUtils::kSOAPEnvURI,
-    nsSOAPUtils::kFaultDetailTagName, aDetail);
-  return NS_OK;
-}
-
-static const char* kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPFault::CanCreateWrapper(const nsIID * iid, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPFault))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPFault::CanCallMethod(const nsIID * iid, const PRUnichar *methodName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPFault))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPFault::CanGetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPFault))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPFault::CanSetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPFault))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPFault.h

@@ -1,51 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPFault_h__
-#define nsSOAPFault_h__
-
-#include "nsString.h"
-#include "nsISOAPFault.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsIDOMElement.h"
-#include "nsCOMPtr.h"
-
-class nsSOAPFault : public nsISOAPFault,
-		    public nsISecurityCheckedComponent
-{
-public:
-  nsSOAPFault(nsIDOMElement* aElement);
-  virtual ~nsSOAPFault();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPFault
-  NS_DECL_NSISOAPFAULT
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-protected:
-  nsCOMPtr<nsIDOMElement> mFaultElement;
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPHeaderBlock.cpp

@@ -1,297 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsString.h"
-#include "nsReadableUtils.h"
-#include "nsSOAPHeaderBlock.h"
-#include "nsSOAPUtils.h"
-#include "nsIServiceManager.h"
-#include "nsISOAPAttachments.h"
-
-nsSOAPHeaderBlock::nsSOAPHeaderBlock()
-{
-  NS_INIT_ISUPPORTS();
-}
-
-nsSOAPHeaderBlock::~nsSOAPHeaderBlock()
-{
-}
-
-NS_IMPL_ISUPPORTS3_CI(nsSOAPHeaderBlock, 
-                   nsISOAPHeaderBlock, 
-                   nsISecurityCheckedComponent,
-                   nsIJSNativeInitializer)
-
-/* attribute AString namespaceURI; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetNamespaceURI(nsAWritableString & aNamespaceURI)
-{
-  NS_ENSURE_ARG_POINTER(&aNamespaceURI);
-  if (mElement) {
-    return mElement->GetNamespaceURI(aNamespaceURI);
-  }
-  else {
-    aNamespaceURI.Assign(mNamespaceURI);
-  }
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetNamespaceURI(const nsAReadableString & aNamespaceURI)
-{
-  if (mElement) {
-    return NS_ERROR_FAILURE;
-  }
-  mNamespaceURI.Assign(aNamespaceURI);
-  return NS_OK;
-}
-
-/* attribute AString name; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetName(nsAWritableString & aName)
-{
-  NS_ENSURE_ARG_POINTER(&aName);
-  if (mElement) {
-    return mElement->GetLocalName(aName);
-  }
-  else {
-    aName.Assign(mName);
-  }
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetName(const nsAReadableString & aName)
-{
-  if (mElement) {
-    return NS_ERROR_FAILURE;
-  }
-  mName.Assign(aName);
-  return NS_OK;
-}
-
-/* attribute AString actorURI; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetActorURI(nsAWritableString & aActorURI)
-{
-  NS_ENSURE_ARG_POINTER(&aActorURI);
-  if (mElement) {
-    return mElement->GetAttributeNS(nsSOAPUtils::kSOAPEnvURI,nsSOAPUtils::kActorAttribute,aActorURI);
-  }
-  else {
-    aActorURI.Assign(mActorURI);
-  }
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetActorURI(const nsAReadableString & aActorURI)
-{
-  if (mElement) {
-    return NS_ERROR_FAILURE;
-  }
-  mActorURI.Assign(aActorURI);
-  return NS_OK;
-}
-
-/* attribute nsISOAPEncoding encoding; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetEncoding(nsISOAPEncoding* * aEncoding)
-{
-  NS_ENSURE_ARG_POINTER(aEncoding);
-  *aEncoding = mEncoding;
-  NS_IF_ADDREF(*aEncoding);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetEncoding(nsISOAPEncoding* aEncoding)
-{
-  mEncoding = aEncoding;
-  if (mElement) {
-    mComputeValue = PR_TRUE;
-    mValue = nsnull;
-    mStatus = NS_OK;
-  }
-  return NS_OK;
-}
-
-/* attribute nsISchemaType schemaType; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetSchemaType(nsISchemaType* * aSchemaType)
-{
-  NS_ENSURE_ARG_POINTER(aSchemaType);
-  *aSchemaType = mSchemaType;
-  NS_IF_ADDREF(*aSchemaType);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetSchemaType(nsISchemaType* aSchemaType)
-{
-  mSchemaType = aSchemaType;
-  if (mElement) {
-    mComputeValue = PR_TRUE;
-    mValue = nsnull;
-    mStatus = NS_OK;
-  }
-  return NS_OK;
-}
-
-/* attribute nsISOAPAttachments attachments; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetAttachments(nsISOAPAttachments* * aAttachments)
-{
-  NS_ENSURE_ARG_POINTER(aAttachments);
-  *aAttachments = mAttachments;
-  NS_IF_ADDREF(*aAttachments);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetAttachments(nsISOAPAttachments* aAttachments)
-{
-  mAttachments = aAttachments;
-  if (mElement) {
-    mComputeValue = PR_TRUE;
-    mValue = nsnull;
-    mStatus = NS_OK;
-  }
-  return NS_OK;
-}
-
-/* attribute nsIDOMElement element; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetElement(nsIDOMElement* * aElement)
-{
-  NS_ENSURE_ARG_POINTER(aElement);
-  *aElement = mElement;
-  NS_IF_ADDREF(*aElement);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetElement(nsIDOMElement* aElement)
-{
-  mElement = aElement;
-  mNamespaceURI.SetLength(0);
-  mName.SetLength(0);
-  mActorURI.SetLength(0);
-  mComputeValue = PR_TRUE;
-  mValue = nsnull;
-  mStatus = NS_OK;
-  return NS_OK;
-}
-
-/* attribute nsIVariant value; */
-NS_IMETHODIMP nsSOAPHeaderBlock::GetValue(nsIVariant* * aValue)
-{
-  NS_ENSURE_ARG_POINTER(aValue);
-  if (mElement    //  Check for auto-computation
-    && mComputeValue
-    && mEncoding)
-  {
-    mComputeValue = PR_FALSE;
-    mStatus = mEncoding->Decode(mElement, mSchemaType, mAttachments, getter_AddRefs(mValue));
-  }
-  *aValue = mValue;
-  NS_IF_ADDREF(*aValue);
-  return mElement ? mStatus : NS_OK;
-}
-NS_IMETHODIMP nsSOAPHeaderBlock::SetValue(nsIVariant* aValue)
-{
-  mValue = aValue;
-  mComputeValue = PR_FALSE;
-  mElement = nsnull;
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsSOAPHeaderBlock::Initialize(JSContext *cx, JSObject *obj, 
-                            PRUint32 argc, jsval *argv)
-{
-
-//  Get the arguments.
-
-  nsCOMPtr<nsIVariant>  value;
-  nsAutoString          name;
-  nsAutoString          namespaceURI;
-  nsAutoString          actorURI;
-  nsCOMPtr<nsISupports> schemaType;
-  nsCOMPtr<nsISupports> encoding;
-
-  if (!JS_ConvertArguments(cx, argc, argv, "/%iv %is %is %is %ip %ip", 
-    getter_AddRefs(value), 
-    NS_STATIC_CAST(nsAString*, &name), 
-    NS_STATIC_CAST(nsAString*, &namespaceURI), 
-    NS_STATIC_CAST(nsAString*, &actorURI), 
-    getter_AddRefs(schemaType),
-    getter_AddRefs(encoding))) return NS_ERROR_ILLEGAL_VALUE;
-
-  nsresult rc = SetValue(value);
-  if (NS_FAILED(rc)) return rc;
-  rc = SetName(name);
-  if (NS_FAILED(rc)) return rc;
-  rc = SetNamespaceURI(namespaceURI);
-  if (NS_FAILED(rc)) return rc;
-  rc = SetActorURI(actorURI);
-  if (NS_FAILED(rc)) return rc;
-  if (schemaType) {
-    nsCOMPtr<nsISchemaType> v = do_QueryInterface(schemaType, &rc);
-    if (NS_FAILED(rc)) return rc;
-    rc = SetSchemaType(v);
-    if (NS_FAILED(rc)) return rc;
-  }
-  if (encoding) {
-    nsCOMPtr<nsISOAPEncoding> v = do_QueryInterface(encoding, &rc);
-    if (NS_FAILED(rc)) return rc;
-    rc = SetEncoding(v);
-    if (NS_FAILED(rc)) return rc;
-  }
-
-  return NS_OK;
-}
-
-static const char* kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPHeaderBlock::CanCreateWrapper(const nsIID * iid, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPHeaderBlock))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPHeaderBlock::CanCallMethod(const nsIID * iid, const PRUnichar *methodName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPHeaderBlock))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPHeaderBlock::CanGetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPHeaderBlock))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPHeaderBlock::CanSetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPHeaderBlock))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPHeaderBlock.h

@@ -1,70 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPHeaderBlock_h__
-#define nsSOAPHeaderBlock_h__
-
-#include "nsString.h"
-#include "nsIVariant.h"
-#include "nsISOAPHeaderBlock.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsIJSNativeInitializer.h"
-#include "nsISOAPEncoding.h"
-#include "nsISchema.h"
-#include "nsIDOMElement.h"
-#include "nsISOAPAttachments.h"
-#include "nsCOMPtr.h"
-
-class nsSOAPHeaderBlock : public nsISOAPHeaderBlock,
-                        public nsISecurityCheckedComponent,
-                        public nsIJSNativeInitializer
-{
-public:
-  nsSOAPHeaderBlock();
-  virtual ~nsSOAPHeaderBlock();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPHeaderBlock
-  NS_DECL_NSISOAPHEADERBLOCK
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-  // nsIJSNativeInitializer
-  NS_IMETHOD Initialize(JSContext *cx, JSObject *obj, 
-                        PRUint32 argc, jsval *argv);
-
-protected:
-  nsString mNamespaceURI;
-  nsString mName;
-  nsString mActorURI;
-  nsCOMPtr<nsISOAPEncoding> mEncoding;
-  nsCOMPtr<nsISchemaType> mSchemaType;
-  nsCOMPtr<nsISOAPAttachments> mAttachments;
-  nsCOMPtr<nsIDOMElement> mElement;
-  nsCOMPtr<nsIVariant> mValue;
-  nsresult mStatus;
-  PRBool mComputeValue;
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPMessage.cpp

@@ -1,475 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsIServiceManager.h"
-#include "nsMemory.h"
-#include "nsIComponentManager.h"
-#include "nsSOAPUtils.h"
-#include "nsSOAPMessage.h"
-#include "nsSOAPParameter.h"
-#include "nsSOAPHeaderBlock.h"
-#include "nsSOAPEncoding.h"
-#include "nsIDOMDocument.h"
-#include "nsIDOMParser.h"
-#include "nsIDOMElement.h"
-#include "nsIDOMNamedNodeMap.h"
-
-static NS_DEFINE_CID(kDOMParserCID, NS_DOMPARSER_CID);
-/////////////////////////////////////////////
-//
-//
-/////////////////////////////////////////////
-  
-nsSOAPMessage::nsSOAPMessage()
-{
-  NS_INIT_ISUPPORTS();
-}
-
-nsSOAPMessage::~nsSOAPMessage()
-{
-}
-
-NS_IMPL_ISUPPORTS2(nsSOAPMessage, 
-                   nsISOAPMessage, 
-                   nsISecurityCheckedComponent)
-
-/* attribute nsIDOMDocument message; */
-NS_IMETHODIMP nsSOAPMessage::GetMessage(nsIDOMDocument * *aMessage)
-{
-  NS_ENSURE_ARG_POINTER(aMessage);
-  *aMessage = mMessage;
-  NS_IF_ADDREF(*aMessage);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPMessage::SetMessage(nsIDOMDocument * aMessage)
-{
-  mMessage = aMessage;
-  return NS_OK;
-}
-
-/* readonly attribute nsIDOMElement envelope; */
-NS_IMETHODIMP nsSOAPMessage::GetEnvelope(nsIDOMElement * *aEnvelope)
-{
-  NS_ENSURE_ARG_POINTER(aEnvelope);
-
-  if (mMessage) {
-    nsCOMPtr<nsIDOMElement> root;
-    mMessage->GetDocumentElement(getter_AddRefs(root));
-    if (root) {
-      nsAutoString name, namespaceURI;
-      root->GetLocalName(name);
-      root->GetNamespaceURI(namespaceURI);
-      if (name.Equals(nsSOAPUtils::kEnvelopeTagName)
-        && namespaceURI.Equals(nsSOAPUtils::kSOAPEnvURI))
-      {
-        *aEnvelope = root;
-        NS_ADDREF(*aEnvelope);
-        return NS_OK;
-      }
-    } 
-
-  }
-  *aEnvelope = nsnull;
-  return NS_OK;
-}
-
-/* readonly attribute nsIDOMElement header; */
-NS_IMETHODIMP nsSOAPMessage::GetHeader(nsIDOMElement * *aHeader)
-{
-  NS_ENSURE_ARG_POINTER(aHeader);
-  nsCOMPtr<nsIDOMElement> env;
-  GetEnvelope(getter_AddRefs(env));
-  if (env) {
-    nsSOAPUtils::GetSpecificChildElement(env, 
-      nsSOAPUtils::kSOAPEnvURI, nsSOAPUtils::kHeaderTagName, 
-      aHeader);
-  }
-  else {
-    *aHeader = nsnull;
-  }
-  return NS_OK;
-}
-
-/* readonly attribute nsIDOMElement body; */
-NS_IMETHODIMP nsSOAPMessage::GetBody(nsIDOMElement * *aBody)
-{
-  NS_ENSURE_ARG_POINTER(aBody);
-  nsCOMPtr<nsIDOMElement> env;
-  GetEnvelope(getter_AddRefs(env));
-  if (env) {
-    nsSOAPUtils::GetSpecificChildElement(env, 
-      nsSOAPUtils::kSOAPEnvURI, nsSOAPUtils::kBodyTagName, 
-      aBody);
-  }
-  else {
-    *aBody = nsnull;
-  }
-  return NS_OK;
-}
-
-/* attribute DOMString actionURI; */
-NS_IMETHODIMP nsSOAPMessage::GetActionURI(nsAWritableString & aActionURI)
-{
-  NS_ENSURE_ARG_POINTER(&aActionURI);
-  aActionURI.Assign(mActionURI);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPMessage::SetActionURI(const nsAReadableString & aActionURI)
-{
-  mActionURI.Assign(aActionURI);
-  return NS_OK;
-}
-
-/* readonly attribute AString methodName; */
-NS_IMETHODIMP nsSOAPMessage::GetMethodName(nsAString & aMethodName)
-{
-  NS_ENSURE_ARG_POINTER(&aMethodName);
-  nsCOMPtr<nsIDOMElement> body;
-  GetBody(getter_AddRefs(body));
-  if (body) {
-    nsCOMPtr<nsIDOMElement> method;
-    nsSOAPUtils::GetFirstChildElement(body, getter_AddRefs(method));
-    if (method) {
-      body->GetLocalName(aMethodName);
-      return NS_OK;
-    }
-  }
-  aMethodName.SetLength(0);
-  return NS_OK;
-}
-
-/* readonly attribute AString targetObjectURI; */
-NS_IMETHODIMP nsSOAPMessage::GetTargetObjectURI(nsAString & aTargetObjectURI)
-{
-  NS_ENSURE_ARG_POINTER(&aTargetObjectURI);
-  nsCOMPtr<nsIDOMElement> body;
-  GetBody(getter_AddRefs(body));
-  if (body) {
-    nsCOMPtr<nsIDOMElement> method;
-    nsSOAPUtils::GetFirstChildElement(body, getter_AddRefs(method));
-    if (method) {
-      body->GetNamespaceURI(aTargetObjectURI);
-      return NS_OK;
-    }
-  }
-  aTargetObjectURI.SetLength(0);
-  return NS_OK;
-}
-
-NS_NAMED_LITERAL_STRING(kEmptySOAPDocStr, "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\" xmlns:xsi=\"http://www.w3.org/1999/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/1999/XMLSchema\"><SOAP-ENV:Header></SOAP-ENV:Header><SOAP-ENV:Body></SOAP-ENV:Body></SOAP-ENV:Envelope>");
-
-/* void encode (in AString aMethodName, in AString aTargetObjectURI, in PRUint32 aHeaderBlockCount, [array, size_is (aHeaderBlockCount)] in nsISOAPHeaderBlock aHeaderBlocks, in PRUint32 aParameterCount, [array, size_is (aParameterCount)] in nsISOAPParameter aParameters); */
-NS_IMETHODIMP nsSOAPMessage::Encode(const nsAString & aMethodName, const nsAString & aTargetObjectURI, PRUint32 aHeaderBlockCount, nsISOAPHeaderBlock **aHeaderBlocks, PRUint32 aParameterCount, nsISOAPParameter **aParameters)
-{
-
-//  Construct the message skeleton
-
-  nsresult rv;
-  nsCOMPtr<nsIDOMNode> ignored;
-  nsCOMPtr<nsIDOMParser> parser = do_CreateInstance(kDOMParserCID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  nsAutoString docstr;
-  rv = parser->ParseFromString(kEmptySOAPDocStr.get(), "text/xml", 
-		               getter_AddRefs(mMessage));
-  if (NS_FAILED(rv)) return rv;
-
-//  Declare the default encoding if one exists
-
-  if (mEncoding) {
-    nsCOMPtr<nsIDOMElement> envelope;
-    rv = GetEnvelope(getter_AddRefs(envelope));
-    if (NS_FAILED(rv)) return rv;
-    if (envelope) {
-      nsAutoString enc;
-      mEncoding->GetStyleURI(enc);
-      envelope->SetAttributeNS(nsSOAPUtils::kSOAPEncodingURI, nsSOAPUtils::kEncodingStyleAttribute, enc);
-    }
-  }
-
-//  Encode and add headers, if any were specified 
-
-  if (aHeaderBlockCount) {
-    nsCOMPtr<nsIDOMElement> parent;
-    rv = GetHeader(getter_AddRefs(parent));
-    if (NS_FAILED(rv)) return rv;
-    nsCOMPtr<nsISupports> next;
-    nsCOMPtr<nsISOAPHeaderBlock> header;
-    nsCOMPtr<nsIDOMElement> element;
-    nsCOMPtr<nsISOAPEncoding> encoding;
-    nsCOMPtr<nsISchemaType> schemaType;
-    nsCOMPtr<nsIVariant> value;
-    nsAutoString name;
-    nsAutoString namespaceURI;
-    nsAutoString actorURI;
-    for (PRUint32 i = 0; i < aHeaderBlockCount; i++) {
-      header = aHeaderBlocks[i];
-      if (!header) return NS_ERROR_FAILURE;
-      rv = header->GetElement(getter_AddRefs(element));
-      if (element) {
-        nsCOMPtr<nsIDOMNode> node1 = (nsIDOMElement*)element;
-        nsCOMPtr<nsIDOMNode> node2;
-        rv = mMessage->ImportNode(node1, PR_TRUE, getter_AddRefs(node1));
-        if (NS_FAILED(rv)) return rv;
-        rv = parent->AppendChild(node2, getter_AddRefs(node1));
-        if (NS_FAILED(rv)) return rv;
-	element = do_QueryInterface(node1);
-      }
-      else {
-        rv = header->GetNamespaceURI(namespaceURI);
-        if (NS_FAILED(rv)) return rv;
-        rv = header->GetName(name);
-        if (NS_FAILED(rv)) return rv;
-        rv = header->GetActorURI(actorURI);
-        if (NS_FAILED(rv)) return rv;
-        rv = header->GetEncoding(getter_AddRefs(encoding));
-        if (NS_FAILED(rv)) return rv;
-        if (!encoding) {
-          encoding = mEncoding;
-        }
-        rv = header->GetSchemaType(getter_AddRefs(schemaType));
-        if (NS_FAILED(rv)) return rv;
-	rv = header->GetValue(getter_AddRefs(value));
-        if (NS_FAILED(rv)) return rv;
-        rv = encoding->Encode(value, namespaceURI, name,
-		        schemaType, nsnull, parent, getter_AddRefs(element));
-        if (NS_FAILED(rv)) return rv;
-        if (!actorURI.IsEmpty()) {
-	  element->SetAttributeNS(nsSOAPUtils::kSOAPEnvPrefix, nsSOAPUtils::kActorAttribute, actorURI);
-        }
-        if (mEncoding != encoding) {
-          nsAutoString enc;
-          encoding->GetStyleURI(enc);
-          element->SetAttributeNS(nsSOAPUtils::kSOAPEncodingURI, nsSOAPUtils::kEncodingStyleAttribute, enc);
-        }
-      }
-    }
-  }
-  nsCOMPtr<nsIDOMElement> body;
-  rv = GetBody(getter_AddRefs(body));
-  if (NS_FAILED(rv)) return rv;
-
-//  Only produce a call element if mMethodName was non-empty
-
-  if (!aMethodName.IsEmpty()) {
-    nsCOMPtr<nsIDOMElement> call;
-    rv = mMessage->CreateElementNS(aTargetObjectURI, aMethodName, getter_AddRefs(call));
-    if (NS_FAILED(rv)) return rv;
-    nsCOMPtr<nsIDOMNode> ignored;
-    rv = body->AppendChild(call, getter_AddRefs(ignored));
-    if (NS_FAILED(rv)) return rv;
-    body = call;
-    nsAutoString prefix;
-    rv = nsSOAPUtils::MakeNamespacePrefixFixed(body, aTargetObjectURI, prefix);
-    if (NS_FAILED(rv)) return rv;
-    if (!prefix.IsEmpty()) {
-      rv = body->SetPrefix(prefix);
-      if (NS_FAILED(rv)) return rv;
-    }
-  }
-
-//  Encode and add all of the parameters into the body
-
-  nsCOMPtr<nsISupports> next;
-  nsCOMPtr<nsISOAPParameter> param;
-  nsCOMPtr<nsIDOMElement> element;
-  nsCOMPtr<nsISOAPEncoding> encoding;
-  nsCOMPtr<nsISchemaType> schemaType;
-  nsCOMPtr<nsIVariant> value;
-  nsAutoString name;
-  nsAutoString namespaceURI;
-  for (PRUint32 i = 0; i < aParameterCount; i++) {
-    param = aParameters[i];
-    if (!param) return NS_ERROR_FAILURE;
-    rv = param->GetElement(getter_AddRefs(element));
-    if (element) {
-      nsCOMPtr<nsIDOMNode> node1 = (nsIDOMElement*)element;
-      nsCOMPtr<nsIDOMNode> node2;
-      rv = mMessage->ImportNode(node1, PR_TRUE, getter_AddRefs(node1));
-      if (NS_FAILED(rv)) return rv;
-      rv = body->AppendChild(node2, getter_AddRefs(node1));
-      if (NS_FAILED(rv)) return rv;
-      element = do_QueryInterface(node1);
-    }
-    else {
-      rv = param->GetNamespaceURI(namespaceURI);
-      if (NS_FAILED(rv)) return rv;
-      rv = param->GetName(name);
-      if (NS_FAILED(rv)) return rv;
-      rv = param->GetEncoding(getter_AddRefs(encoding));
-      if (NS_FAILED(rv)) return rv;
-      if (!encoding) {
-        encoding = mEncoding;
-      }
-      rv = param->GetSchemaType(getter_AddRefs(schemaType));
-      if (NS_FAILED(rv)) return rv;
-      rv = param->GetValue(getter_AddRefs(value));
-      if (NS_FAILED(rv)) return rv;
-      rv = encoding->Encode(value, namespaceURI, name,
-		      schemaType, nsnull, body, getter_AddRefs(element));
-      if (NS_FAILED(rv)) return rv;
-      if (mEncoding != encoding) {
-        nsAutoString enc;
-        encoding->GetStyleURI(enc);
-        element->SetAttributeNS(nsSOAPUtils::kSOAPEncodingURI, nsSOAPUtils::kEncodingStyleAttribute, enc);
-      }
-    }
-  }
-  return NS_OK;
-}
-
-static NS_DEFINE_CID(kMemoryCID, NS_MEMORY_CID);
-
-/* void getHeaderBlocks (out PRUint32 aCount, [array, size_is (aCount), retval] out nsISOAPHeaderBlock aHeaderBlocks); */
-NS_IMETHODIMP nsSOAPMessage::GetHeaderBlocks(PRUint32 *aCount, nsISOAPHeaderBlock ***aHeaderBlocks)
-{
-  nsCOMPtr<nsIMemory> memory = do_GetService(kMemoryCID);
-  *aCount = 0;
-  *aHeaderBlocks = nsnull;
-  int count = 0;
-  int length = 0;
-  nsCOMPtr<nsIDOMElement> element;
-  nsresult rv = GetHeader(getter_AddRefs(element));
-  if (NS_FAILED(rv)) return rv;
-  nsCOMPtr<nsIDOMElement> next;
-  nsCOMPtr<nsISOAPHeaderBlock> header;
-  nsSOAPUtils::GetFirstChildElement(element, getter_AddRefs(next));
-  while (next) {
-    if (length == count) {
-      length = length ? 2 * length : 10;
-      *aHeaderBlocks = (nsISOAPHeaderBlock* *)memory->Realloc(*aHeaderBlocks, length * sizeof(**aHeaderBlocks));
-    }
-    element = next;
-    header = new nsSOAPHeaderBlock();
-    if (NS_FAILED(rv)) return rv;
-    // XXX can't addref a COMPTr
-    //NS_ADDREF(header);
-    (*aHeaderBlocks)[(*aCount)++] = header;
-    rv = header->SetElement(element);
-    if (NS_FAILED(rv)) return rv;
-    nsSOAPUtils::GetNextSiblingElement(element, getter_AddRefs(next));
-  }
-  if (*aCount) {
-    *aHeaderBlocks = (nsISOAPHeaderBlock* *)memory->Realloc(*aHeaderBlocks, (*aCount) * sizeof(**aHeaderBlocks));
-  }
-  return NS_OK;
-}
-
-/* void getParameters (in boolean aDocumentStyle, out PRUint32 aCount, [array, size_is (aCount), retval] out nsISOAPParameter aParameters); */
-NS_IMETHODIMP nsSOAPMessage::GetParameters(PRBool aDocumentStyle, PRUint32 *aCount, nsISOAPParameter ***aParameters)
-{
-  nsCOMPtr<nsIMemory> memory = do_GetService(kMemoryCID);
-  *aCount = 0;
-  *aParameters = nsnull;
-  int count = 0;
-  int length = 0;
-  nsCOMPtr<nsIDOMElement> element;
-  nsresult rv = GetHeader(getter_AddRefs(element));
-  if (NS_FAILED(rv)) return rv;
-  nsCOMPtr<nsIDOMElement> next;
-  nsCOMPtr<nsISOAPParameter> param;
-  nsSOAPUtils::GetFirstChildElement(element, getter_AddRefs(next));
-  while (next) {
-    if (length == count) {
-      length = length ? 2 * length : 10;
-      *aParameters = (nsISOAPParameter* *)memory->Realloc(*aParameters, length * sizeof(**aParameters));
-    }
-    element = next;
-    param = new nsSOAPParameter();
-    if (NS_FAILED(rv)) return rv;
-    // XXX can't addref a COMPTr
-    //NS_ADDREF(param);
-    (*aParameters)[(*aCount)++] = param;
-    rv = param->SetElement(element);
-    if (NS_FAILED(rv)) return rv;
-    nsSOAPUtils::GetNextSiblingElement(element, getter_AddRefs(next));
-  }
-  if (*aCount) {
-    *aParameters = (nsISOAPParameter* *)memory->Realloc(*aParameters, (*aCount) * sizeof(**aParameters));
-  }
-  return NS_OK;
-}
-
-/* attribute nsISOAPEncoding encoding; */
-NS_IMETHODIMP nsSOAPMessage::GetEncoding(nsISOAPEncoding* * aEncoding)
-{
-  NS_ENSURE_ARG_POINTER(aEncoding);
-  if (!mEncoding) {
-    mEncoding = new nsSOAPEncoding();
-    if (!mEncoding)
-      return NS_ERROR_OUT_OF_MEMORY;
-  }
-  *aEncoding = mEncoding;
-  NS_IF_ADDREF(*aEncoding);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPMessage::SetEncoding(nsISOAPEncoding* aEncoding)
-{
-  mEncoding = aEncoding;
-  return NS_OK;
-}
-
-static const char*kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPMessage::CanCreateWrapper(const nsIID * iid, char**_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPMessage))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPMessage::CanCallMethod(const nsIID * iid, const PRUnichar*methodName, char**_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPMessage))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPMessage::CanGetProperty(const nsIID * iid, const PRUnichar*propertyName, char**_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPMessage))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPMessage::CanSetProperty(const nsIID * iid, const PRUnichar*propertyName, char**_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPMessage))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPMessage.h

@@ -1,58 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPMessage_h__
-#define nsSOAPMessage_h__
-
-#include "nsString.h"
-#include "nsISOAPEncoding.h"
-#include "nsISOAPMessage.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsIDOMElement.h"
-#include "nsIDOMDocument.h"
-#include "nsISupportsArray.h"
-#include "nsCOMPtr.h"
-#include "nsIVariant.h"
-
-class nsSOAPMessage : public nsISOAPMessage, 
-  public nsISecurityCheckedComponent
-{
-public:
-  nsSOAPMessage();
-  virtual ~nsSOAPMessage();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPMessage
-  NS_DECL_NSISOAPMESSAGE
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-protected:
-
-  nsCOMPtr<nsIDOMDocument> mMessage;
-  nsCOMPtr<nsISOAPEncoding> mEncoding;
-  nsString mActionURI;
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPParameter.cpp

@@ -1,271 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsString.h"
-#include "nsReadableUtils.h"
-#include "nsSOAPParameter.h"
-#include "nsSOAPUtils.h"
-#include "nsIServiceManager.h"
-#include "nsISOAPAttachments.h"
-
-nsSOAPParameter::nsSOAPParameter()
-{
-  NS_INIT_ISUPPORTS();
-}
-
-nsSOAPParameter::~nsSOAPParameter()
-{
-}
-
-NS_IMPL_ISUPPORTS3_CI(nsSOAPParameter, 
-                      nsISOAPParameter, 
-                      nsISecurityCheckedComponent,
-                      nsIJSNativeInitializer)
-
-/* attribute AString namespaceURI; */
-NS_IMETHODIMP nsSOAPParameter::GetNamespaceURI(nsAWritableString & aNamespaceURI)
-{
-  NS_ENSURE_ARG_POINTER(&aNamespaceURI);
-  if (mElement) {
-    return mElement->GetNamespaceURI(aNamespaceURI);
-  }
-  else {
-    aNamespaceURI.Assign(mNamespaceURI);
-  }
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetNamespaceURI(const nsAReadableString & aNamespaceURI)
-{
-  if (mElement) {
-    return NS_ERROR_FAILURE;
-  }
-  mNamespaceURI.Assign(aNamespaceURI);
-  return NS_OK;
-}
-
-/* attribute AString name; */
-NS_IMETHODIMP nsSOAPParameter::GetName(nsAWritableString & aName)
-{
-  NS_ENSURE_ARG_POINTER(&aName);
-  if (mElement) {
-    return mElement->GetLocalName(aName);
-  }
-  else {
-    aName.Assign(mName);
-  }
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetName(const nsAReadableString & aName)
-{
-  if (mElement) {
-    return NS_ERROR_FAILURE;
-  }
-  mName.Assign(aName);
-  return NS_OK;
-}
-
-/* attribute nsISOAPEncoding encoding; */
-NS_IMETHODIMP nsSOAPParameter::GetEncoding(nsISOAPEncoding* * aEncoding)
-{
-  NS_ENSURE_ARG_POINTER(aEncoding);
-  *aEncoding = mEncoding;
-  NS_IF_ADDREF(*aEncoding);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetEncoding(nsISOAPEncoding* aEncoding)
-{
-  mEncoding = aEncoding;
-  if (mElement) {
-    mComputeValue = PR_TRUE;
-    mValue = nsnull;
-    mStatus = NS_OK;
-  }
-  return NS_OK;
-}
-
-/* attribute nsISchemaType schemaType; */
-NS_IMETHODIMP nsSOAPParameter::GetSchemaType(nsISchemaType* * aSchemaType)
-{
-  NS_ENSURE_ARG_POINTER(aSchemaType);
-  *aSchemaType = mSchemaType;
-  NS_IF_ADDREF(*aSchemaType);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetSchemaType(nsISchemaType* aSchemaType)
-{
-  mSchemaType = aSchemaType;
-  if (mElement) {
-    mComputeValue = PR_TRUE;
-    mValue = nsnull;
-    mStatus = NS_OK;
-  }
-  return NS_OK;
-}
-
-/* attribute nsISOAPAttachments attachments; */
-NS_IMETHODIMP nsSOAPParameter::GetAttachments(nsISOAPAttachments* * aAttachments)
-{
-  NS_ENSURE_ARG_POINTER(aAttachments);
-  *aAttachments = mAttachments;
-  NS_IF_ADDREF(*aAttachments);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetAttachments(nsISOAPAttachments* aAttachments)
-{
-  mAttachments = aAttachments;
-  if (mElement) {
-    mComputeValue = PR_TRUE;
-    mValue = nsnull;
-    mStatus = NS_OK;
-  }
-  return NS_OK;
-}
-
-/* attribute nsIDOMElement element; */
-NS_IMETHODIMP nsSOAPParameter::GetElement(nsIDOMElement* * aElement)
-{
-  NS_ENSURE_ARG_POINTER(aElement);
-  *aElement = mElement;
-  NS_IF_ADDREF(*aElement);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetElement(nsIDOMElement* aElement)
-{
-  mElement = aElement;
-  mNamespaceURI.SetLength(0);
-  mName.SetLength(0);
-  mComputeValue = PR_TRUE;
-  mValue = nsnull;
-  mStatus = NS_OK;
-  return NS_OK;
-}
-
-/* attribute nsIVariant value; */
-NS_IMETHODIMP nsSOAPParameter::GetValue(nsIVariant* * aValue)
-{
-  NS_ENSURE_ARG_POINTER(aValue);
-  if (mElement    //  Check for auto-computation
-    && mComputeValue
-    && mEncoding)
-  {
-    mComputeValue = PR_FALSE;
-    mStatus = mEncoding->Decode(mElement, mSchemaType, mAttachments, getter_AddRefs(mValue));
-  }
-  *aValue = mValue;
-  NS_IF_ADDREF(*aValue);
-  return mElement ? mStatus : NS_OK;
-}
-NS_IMETHODIMP nsSOAPParameter::SetValue(nsIVariant* aValue)
-{
-  mValue = aValue;
-  mComputeValue = PR_FALSE;
-  mElement = nsnull;
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
-nsSOAPParameter::Initialize(JSContext *cx, JSObject *obj, 
-                            PRUint32 argc, jsval *argv)
-{
-
-//  Get the arguments.
-
-  nsCOMPtr<nsIVariant>  value;
-  nsAutoString          name;
-  nsAutoString          namespaceURI;
-  nsCOMPtr<nsISupports> schemaType;
-  nsCOMPtr<nsISupports> encoding;
-
-  if (!JS_ConvertArguments(cx, argc, argv, "/%iv %is %is %ip %ip", 
-    getter_AddRefs(value), 
-    NS_STATIC_CAST(nsAString*, &name), 
-    NS_STATIC_CAST(nsAString*, &namespaceURI), 
-    getter_AddRefs(schemaType),
-    getter_AddRefs(encoding))) return NS_ERROR_ILLEGAL_VALUE;
-
-  nsresult rc = SetValue(value);
-  if (NS_FAILED(rc)) return rc;
-  rc = SetName(name);
-  if (NS_FAILED(rc)) return rc;
-  rc = SetNamespaceURI(namespaceURI);
-  if (NS_FAILED(rc)) return rc;
-  if (schemaType) {
-    nsCOMPtr<nsISchemaType> v = do_QueryInterface(schemaType, &rc);
-    if (NS_FAILED(rc)) return rc;
-    rc = SetSchemaType(v);
-    if (NS_FAILED(rc)) return rc;
-  }
-  if (encoding) {
-    nsCOMPtr<nsISOAPEncoding> v = do_QueryInterface(encoding, &rc);
-    if (NS_FAILED(rc)) return rc;
-    rc = SetEncoding(v);
-    if (NS_FAILED(rc)) return rc;
-  }
-
-  return NS_OK;
-}
-
-static const char* kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPParameter::CanCreateWrapper(const nsIID * iid, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPParameter))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPParameter::CanCallMethod(const nsIID * iid, const PRUnichar *methodName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPParameter))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPParameter::CanGetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPParameter))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPParameter::CanSetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPParameter))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPParameter.h

@@ -1,69 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPParameter_h__
-#define nsSOAPParameter_h__
-
-#include "nsString.h"
-#include "nsIVariant.h"
-#include "nsISOAPParameter.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsIJSNativeInitializer.h"
-#include "nsISOAPEncoding.h"
-#include "nsISchema.h"
-#include "nsIDOMElement.h"
-#include "nsISOAPAttachments.h"
-#include "nsCOMPtr.h"
-
-class nsSOAPParameter : public nsISOAPParameter,
-                        public nsISecurityCheckedComponent,
-                        public nsIJSNativeInitializer
-{
-public:
-  nsSOAPParameter();
-  virtual ~nsSOAPParameter();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPParameter
-  NS_DECL_NSISOAPPARAMETER
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-  // nsIJSNativeInitializer
-  NS_IMETHOD Initialize(JSContext *cx, JSObject *obj, 
-                        PRUint32 argc, jsval *argv);
-
-protected:
-  nsString mNamespaceURI;
-  nsString mName;
-  nsCOMPtr<nsISOAPEncoding> mEncoding;
-  nsCOMPtr<nsISchemaType> mSchemaType;
-  nsCOMPtr<nsISOAPAttachments> mAttachments;
-  nsCOMPtr<nsIDOMElement> mElement;
-  nsCOMPtr<nsIVariant> mValue;
-  nsresult mStatus;
-  PRBool mComputeValue;
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPResponse.cpp

@@ -1,122 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsSOAPResponse.h"
-#include "nsSOAPUtils.h"
-#include "nsSOAPFault.h"
-#include "nsISOAPParameter.h"
-
-nsSOAPResponse::nsSOAPResponse()
-{
-}
-
-nsSOAPResponse::~nsSOAPResponse()
-{
-  /* destructor code */
-}
-
-NS_IMPL_ISUPPORTS_INHERITED1(nsSOAPResponse, nsSOAPMessage, nsISOAPResponse)
-
-/* attribute nsISOAPCall respondingTo; */
-NS_IMETHODIMP nsSOAPResponse::GetRespondingTo(nsISOAPCall * *aRespondingTo)
-{
-  NS_ENSURE_ARG_POINTER(aRespondingTo);
-  *aRespondingTo = mRespondingTo;
-  NS_IF_ADDREF(*aRespondingTo);
-  return NS_OK;
-}
-NS_IMETHODIMP nsSOAPResponse::SetRespondingTo(nsISOAPCall * aRespondingTo)
-{
-  mRespondingTo = aRespondingTo;
-  return NS_OK;
-}
-
-/* readonly attribute nsISOAPFault fault; */
-NS_IMETHODIMP nsSOAPResponse::GetFault(nsISOAPFault * *aFault)
-{
-  NS_ENSURE_ARG_POINTER(aFault);
-  nsCOMPtr<nsIDOMElement> body;
-
-  *aFault = nsnull;
-  GetBody(getter_AddRefs(body));
-  if (body) {
-    nsSOAPUtils::GetSpecificChildElement(body, 
-      nsSOAPUtils::kSOAPEnvURI, nsSOAPUtils::kFaultTagName, 
-      getter_AddRefs(body));
-    if (body) {
-      *aFault = new nsSOAPFault(body);
-      if (!*aFault)
-        return NS_ERROR_OUT_OF_MEMORY;
-      NS_ADDREF(*aFault);
-    }
-  }
-  else {
-    *aFault = nsnull;
-  }
-  return NS_OK;
-}
-
-static const char* kAllAccess = "AllAccess";
-
-/* string canCreateWrapper (in nsIIDPtr iid); */
-NS_IMETHODIMP 
-nsSOAPResponse::CanCreateWrapper(const nsIID * iid, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPResponse))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canCallMethod (in nsIIDPtr iid, in wstring methodName); */
-NS_IMETHODIMP 
-nsSOAPResponse::CanCallMethod(const nsIID * iid, const PRUnichar *methodName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPResponse))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canGetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPResponse::CanGetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPResponse))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}
-
-/* string canSetProperty (in nsIIDPtr iid, in wstring propertyName); */
-NS_IMETHODIMP 
-nsSOAPResponse::CanSetProperty(const nsIID * iid, const PRUnichar *propertyName, char **_retval)
-{
-  if (iid->Equals(NS_GET_IID(nsISOAPResponse))) {
-    *_retval = nsCRT::strdup(kAllAccess);
-  }
-
-  return NS_OK;
-}

mozilla/extensions/webservices/soap/src/nsSOAPResponse.h

@@ -1,56 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPResponse_h__
-#define nsSOAPResponse_h__
-
-#include "nsString.h"
-#include "nsSOAPCall.h"
-#include "nsISOAPResponse.h"
-#include "nsISecurityCheckedComponent.h"
-#include "nsIDOMDocument.h"
-#include "nsIDOMElement.h"
-#include "nsCOMPtr.h"
-
-class nsSOAPResponse : public nsSOAPMessage,
-                       public nsISOAPResponse
-{
-public:
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPResponse
-  NS_FORWARD_NSISOAPMESSAGE(nsSOAPMessage::)
-
-  // nsISOAPResponse
-  NS_DECL_NSISOAPRESPONSE
-
-  // nsISecurityCheckedComponent
-  NS_DECL_NSISECURITYCHECKEDCOMPONENT
-
-  nsSOAPResponse();
-  virtual ~nsSOAPResponse();
-
-protected:
-  nsCOMPtr<nsISOAPCall> mRespondingTo;
-};
-
-#endif

mozilla/extensions/webservices/soap/src/nsSOAPUtils.cpp

@@ -1,426 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsSOAPUtils.h"
-#include "nsIDOMText.h"
-#include "nsIDOMNamedNodeMap.h"
-#include "nsCOMPtr.h"
-
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kSOAPEnvURI,"http://schemas.xmlsoap.org/soap/envelope/");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kSOAPEncodingURI,"http://schemas.xmlsoap.org/soap/encoding/");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kSOAPEnvPrefix,"SOAP-ENV");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kSOAPEncodingPrefix,"SOAP-ENC");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXSIURI,"http://www.w3.org/1999/XMLSchema-instance");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXSDURI,"http://www.w3.org/1999/XMLSchema");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXSIPrefix,"xsi");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXSITypeAttribute,"type");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXSDPrefix,"xsd");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kEncodingStyleAttribute,"encodingStyle");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kActorAttribute,"actor");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kEnvelopeTagName,"Envelope");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kHeaderTagName,"Header");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kBodyTagName,"Body");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kFaultTagName,"Fault");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kFaultCodeTagName,"faultcode");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kFaultStringTagName,"faultstring");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kFaultActorTagName,"faultactor");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kFaultDetailTagName,"detail");
-
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kEncodingSeparator,"#");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kQualifiedSeparator,":");
-
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXMLNamespaceNamespaceURI, "htp://www.w3.org/2000/xmlns/");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXMLNamespaceURI, "htp://www.w3.org/XML/1998/namespace");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXMLPrefix, "xml:");
-NS_NAMED_LITERAL_STRING(nsSOAPUtils::kXMLNamespacePrefix, "xmlns:");
-
-void 
-nsSOAPUtils::GetSpecificChildElement(
-  nsIDOMElement *aParent, 
-  const nsAReadableString& aNamespace, 
-  const nsAReadableString& aType, 
-  nsIDOMElement * *aElement)
-{
-  nsCOMPtr<nsIDOMElement> sibling;
-
-  *aElement = nsnull;
-  GetFirstChildElement(aParent, getter_AddRefs(sibling));
-  if (sibling)
-  {
-    GetSpecificSiblingElement(sibling,
-      aNamespace, aType, aElement);
-  }
-}
-
-void 
-nsSOAPUtils::GetSpecificSiblingElement(
-  nsIDOMElement *aSibling, 
-  const nsAReadableString& aNamespace, 
-  const nsAReadableString& aType, 
-  nsIDOMElement * *aElement)
-{
-  nsCOMPtr<nsIDOMElement> sibling;
-
-  *aElement = nsnull;
-  sibling = aSibling;
-  do {
-    nsAutoString name, namespaceURI;
-    sibling->GetLocalName(name);
-    sibling->GetNamespaceURI(namespaceURI);
-    if (name.Equals(aType)
-      && namespaceURI.Equals(nsSOAPUtils::kSOAPEnvURI))
-    {
-      *aElement = sibling;
-      NS_ADDREF(*aElement);
-      return;
-    }
-    nsCOMPtr<nsIDOMElement> temp = sibling;
-    GetNextSiblingElement(temp, getter_AddRefs(sibling));
-  } while (sibling);
-}
-
-void
-nsSOAPUtils::GetFirstChildElement(nsIDOMElement* aParent, 
-                                  nsIDOMElement** aElement)
-{
-  nsCOMPtr<nsIDOMNode> child;
-
-  *aElement = nsnull;
-  aParent->GetFirstChild(getter_AddRefs(child));
-  while (child) {
-    PRUint16 type;
-    child->GetNodeType(&type);
-    if (nsIDOMNode::ELEMENT_NODE == type) {
-      child->QueryInterface(NS_GET_IID(nsIDOMElement), (void**)aElement);
-      break;
-    }
-    nsCOMPtr<nsIDOMNode> temp = child;
-    GetNextSibling(temp, getter_AddRefs(child));
-  }
-}
-
-void
-nsSOAPUtils::GetNextSiblingElement(nsIDOMElement* aStart, 
-                                   nsIDOMElement** aElement)
-{
-  nsCOMPtr<nsIDOMNode> sibling;
-
-  *aElement = nsnull;
-  GetNextSibling(aStart, getter_AddRefs(sibling));
-  while (sibling) {
-    PRUint16 type;
-    sibling->GetNodeType(&type);
-    if (nsIDOMNode::ELEMENT_NODE == type) {
-      sibling->QueryInterface(NS_GET_IID(nsIDOMElement), (void**)aElement);
-      break;
-    }
-    nsCOMPtr<nsIDOMNode> temp = sibling;
-    GetNextSibling(temp, getter_AddRefs(sibling));
-  }
-}
-
-nsresult 
-nsSOAPUtils::GetElementTextContent(nsIDOMElement* aElement, 
-                                   nsAWritableString& aText)
-{
-  nsCOMPtr<nsIDOMNode> child;
-  nsAutoString rtext;
-  aElement->GetFirstChild(getter_AddRefs(child));
-  while (child) {
-    PRUint16 type;
-    child->GetNodeType(&type);
-    if (nsIDOMNode::TEXT_NODE == type
-        || nsIDOMNode::CDATA_SECTION_NODE == type) {
-      nsCOMPtr<nsIDOMText> text = do_QueryInterface(child);
-      nsAutoString data;
-      text->GetData(data);
-      rtext.Append(data);
-    }
-    else if (nsIDOMNode::ELEMENT_NODE == type) {
-      return NS_ERROR_ILLEGAL_VALUE;	//  This was interpreted as a simple value, yet had complex content in it.
-    }
-    nsCOMPtr<nsIDOMNode> temp = child;
-    GetNextSibling(temp, getter_AddRefs(child));
-  }
-  aText.Assign(rtext);
-  return NS_OK;
-}
-
-PRBool
-nsSOAPUtils::HasChildElements(nsIDOMElement* aElement)
-{
-  nsCOMPtr<nsIDOMNode> child;
-
-  aElement->GetFirstChild(getter_AddRefs(child));
-  while (child) {
-    PRUint16 type;
-    child->GetNodeType(&type);
-    if (nsIDOMNode::ELEMENT_NODE == type) {
-      return PR_TRUE;
-    }
-    nsCOMPtr<nsIDOMNode> temp = child;
-    GetNextSibling(temp, getter_AddRefs(child));
-  }
-
-  return PR_FALSE;
-}
-
-void
-nsSOAPUtils::GetNextSibling(nsIDOMNode* aSibling, nsIDOMNode **aNext)
-{
-  nsCOMPtr<nsIDOMNode> last;
-  nsCOMPtr<nsIDOMNode> current;
-  PRUint16 type;
-
-  *aNext = nsnull;
-  last = aSibling;
-
-  last->GetNodeType(&type);
-  if (nsIDOMNode::ENTITY_REFERENCE_NODE == type) {
-    last->GetFirstChild(getter_AddRefs(current));
-    if (!last)
-    {
-      last->GetNextSibling(getter_AddRefs(current));
-    }
-  }
-  else {
-    last->GetNextSibling(getter_AddRefs(current));
-  }
-  while (!current)
-  {
-    last->GetParentNode(getter_AddRefs(current));
-    current->GetNodeType(&type);
-    if (nsIDOMNode::ENTITY_REFERENCE_NODE == type) {
-      last = current;
-      last->GetNextSibling(getter_AddRefs(current));
-    }
-    else {
-      current = nsnull;
-      break;
-    }
-  }
-  *aNext = current;
-  NS_IF_ADDREF(*aNext);
-}
-nsresult nsSOAPUtils::GetNamespaceURI(nsIDOMElement* aScope,
-                                  const nsAReadableString & aQName, 
-                                  nsAWritableString & aURI)
-{
-  aURI.Truncate(0);
-  PRInt32 i = aQName.FindChar(':');
-  if (i < 0) {
-    return NS_OK;
-  }
-  nsAutoString prefix;
-  aQName.Left(prefix, i);
-
-  if (prefix.Equals(kXMLPrefix)) {
-    aURI.Assign(kXMLNamespaceURI);
-    return NS_OK;
-  }
-
-  nsresult rc;
-  nsCOMPtr<nsIDOMNode> current = aScope;
-  nsCOMPtr<nsIDOMNamedNodeMap> attrs;
-  nsCOMPtr<nsIDOMNode> temp;
-  nsAutoString value;
-  while (current != nsnull) {
-    rc = current->GetAttributes(getter_AddRefs(attrs));
-    if (NS_FAILED(rc)) return rc;
-    if (attrs) {
-      rc = attrs->GetNamedItemNS(kXMLNamespaceNamespaceURI, prefix, getter_AddRefs(temp));
-      if (NS_FAILED(rc)) return rc;
-      if (temp != nsnull)
-	return temp->GetNodeValue(aURI);
-    }
-    rc = current->GetParentNode(getter_AddRefs(temp));
-    if (NS_FAILED(rc)) return rc;
-    current = temp;
-  }
-  return NS_ERROR_FAILURE;
-}
-
-nsresult nsSOAPUtils::GetLocalName(const nsAReadableString & aQName, 
-                                  nsAWritableString & aLocalName)
-{
-  PRInt32 i = aQName.FindChar(':');
-  if (i < 0)
-    aLocalName = aQName;
-  else
-    aQName.Mid(aLocalName, i, aQName.Length() - i);
-  return NS_OK;
-}
-
-nsresult 
-nsSOAPUtils::MakeNamespacePrefix(nsIDOMElement* aScope,
-                                 const nsAReadableString & aURI,
-                                 nsAWritableString & aPrefix)
-{
-//  This may change for level 3 serialization, so be sure to gut this
-//  and call the standardized level 3 method when it is available.
-  aPrefix.Truncate(0);
-  if (aURI.IsEmpty())
-    return NS_OK;
-  if (aURI.Equals(nsSOAPUtils::kXMLNamespaceURI)) {
-    aPrefix.Assign(nsSOAPUtils::kXMLPrefix);
-    return NS_OK;
-  }
-  nsCOMPtr<nsIDOMNode> current = aScope;
-  nsCOMPtr<nsIDOMNamedNodeMap> attrs;
-  nsCOMPtr<nsIDOMNode> temp;
-  nsAutoString tstr;
-  nsresult rc;
-  PRUint32 maxns = 0;	//  Keep track of max generated NS
-  for (;;) {
-    rc = current->GetAttributes(getter_AddRefs(attrs));
-    if (NS_FAILED(rc)) return rc;
-    if (attrs) {
-      PRUint32 i = 0;
-      for (;;)
-      {
-        attrs->Item(i++, getter_AddRefs(temp));
-        if (!temp)
-          break;
-        temp->GetNamespaceURI(tstr);
-        if (!tstr.Equals(nsSOAPUtils::kXMLNamespaceNamespaceURI))
-          continue;
-        temp->GetNodeValue(tstr);
-        if (tstr.Equals(aURI)) {
-          nsAutoString prefix;
-          rc = temp->GetLocalName(prefix);
-          if (NS_FAILED(rc)) return rc;
-          nsCOMPtr<nsIDOMNode> check = aScope;
-          PRBool hasDecl;
-	  nsCOMPtr<nsIDOMElement> echeck;
-          while (check != current) { // Make sure prefix is not overridden
-	    echeck = do_QueryInterface(check);
-	    if (echeck) {
-	      rc = echeck->HasAttributeNS(nsSOAPUtils::kXMLNamespaceNamespaceURI, prefix, &hasDecl);
-              if (NS_FAILED(rc)) return rc;
-	      if (hasDecl)
-	        break;
-              current->GetParentNode(getter_AddRefs(temp));
-	      current = temp;
-	    }
-          }
-          if (check == current) {
-	    aPrefix.Assign(prefix);
-	    return NS_OK;
-          }
-	}
-	rc = temp->GetLocalName(tstr);
-        if (NS_FAILED(rc)) 
-	  return rc;
-	else {	//  Decode the generated namespace into a number
-          nsReadingIterator<PRUnichar> i1;
-          nsReadingIterator<PRUnichar> i2;
-	  tstr.BeginReading(i1);
-	  tstr.EndReading(i2);
-	  if (i1 == i2 || *i1 != 'n') 
-	    continue;
-	  i1++;
-	  if (i1 == i2 || *i1 != 's') 
-	    continue;
-	  i1++;
-	  PRUint32 n = 0;
-	  while (i1 != i2) {
-	    PRUnichar c = *i1;
-	    i1++;
-	    if (c < '0' || c > '9') {
-	      n = 0;
-	      break;
-	    }
-	    n = n * 10 + (c - '0');
-	  }
-	  if (n > maxns)
-            maxns = n;
-	}
-      }
-    }
-    current->GetParentNode(getter_AddRefs(temp));
-    if (temp)
-      current = temp;
-    else
-      break;
-  }
-// Create a unique prefix...
-  PRUint32 len = 3;
-  PRUint32 c = maxns + 1;
-  while (c >= 10) {
-    c = c / 10;
-    len++;
-  }
-// Set the length and write it backwards since that's the easiest way..
-  aPrefix.SetLength(len);
-  nsWritingIterator<PRUnichar> i2;
-  aPrefix.EndWriting(i2);
-  c = maxns + 1;
-  while (c > 0) {
-    PRUint32 r = c % 10;
-    c = c / 10;
-    i2--;
-    *i2 = (PRUnichar)(r + '0');
-  }
-  i2--;
-  *i2 = 's';
-  i2--;
-  *i2 = 'n';
-  return NS_OK;
-}
-
-nsresult 
-nsSOAPUtils::MakeNamespacePrefixFixed(nsIDOMElement* aScope,
-		                      const nsAReadableString & aURI,
-				      nsAWritableString & aPrefix)
-{
-  if (aURI.Equals(kSOAPEncodingURI))
-    aPrefix = kSOAPEncodingPrefix;
-  else if (aURI.Equals(kSOAPEnvURI))
-    aPrefix = kSOAPEnvPrefix;
-  else if (aURI.Equals(kXSIURI))
-    aPrefix = kXSIPrefix;
-  else if (aURI.Equals(kXSDURI))
-    aPrefix = kXSDPrefix;
-  else
-    return MakeNamespacePrefix(aScope, aURI, aPrefix);
-
-  return NS_OK;
-}
-
-PRBool nsSOAPUtils::StartsWith(nsAReadableString& aSuper,
-		           nsAReadableString& aSub)
-{
-  PRUint32 c1 = aSuper.Length();
-  PRUint32 c2 = aSub.Length();
-  if (c1 < c2) return PR_FALSE;
-  if (c1 == c2) return aSuper.Equals(aSub);
-  nsReadingIterator<PRUnichar> i1;
-  nsReadingIterator<PRUnichar> i2;
-  aSuper.BeginReading(i1);
-  aSub.BeginReading(i2);
-  while (c2--) {
-    if (*i1 != *i2) return PR_FALSE;
-    i1++;
-    i2++;
-  }
-  return PR_TRUE;
-}

mozilla/extensions/webservices/soap/src/nsSOAPUtils.h

@@ -1,109 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsSOAPUtils_h__
-#define nsSOAPUtils_h__
-
-#include "nsString.h"
-#include "nsIDOMElement.h"
-
-class nsSOAPUtils {
-public:
-  static void GetSpecificChildElement(nsIDOMElement *aParent, 
-                                      const nsAReadableString& aNamespace, 
-                                      const nsAReadableString& aType, 
-                                      nsIDOMElement * *aElement);
-  static void GetSpecificSiblingElement(nsIDOMElement *aSibling, 
-                                        const nsAReadableString& aNamespace, 
-                                        const nsAReadableString& aType, 
-                                        nsIDOMElement * *aElement);
-  static void GetFirstChildElement(nsIDOMElement* aParent, 
-                                   nsIDOMElement** aElement);
-  static void GetNextSiblingElement(nsIDOMElement* aStart, 
-                                    nsIDOMElement** aElement);
-  static nsresult GetElementTextContent(nsIDOMElement* aElement, 
-                                    nsAWritableString& aText);
-  static PRBool HasChildElements(nsIDOMElement* aElement);
-
-  static void GetNextSibling(nsIDOMNode* aSibling, 
-                             nsIDOMNode **aNext);
-  static nsresult MakeNamespacePrefix(nsIDOMElement* aElement,
-                                     const nsAReadableString & aURI,
-                                     nsAWritableString & aPrefix);
-  static nsresult MakeNamespacePrefixFixed(nsIDOMElement* aElement,
-                                     const nsAReadableString & aURI,
-                                     nsAWritableString & aPrefix);
-  static nsresult GetNamespaceURI(nsIDOMElement* aElement,
-                                  const nsAReadableString & aQName, 
-                                  nsAWritableString & aURI);
-  static nsresult GetLocalName(const nsAReadableString & aQName, 
-                                  nsAWritableString & aLocalName);
-
-// All those missing string functions have to come from somewhere...
-
-  static PRBool StartsWith(nsAReadableString& aSuper,
-		           nsAReadableString& aSub);
-  static nsDependentString kSOAPEnvURI;
-  static nsDependentString kSOAPEncodingURI;
-  static nsDependentString kSOAPEnvPrefix;
-  static nsDependentString kSOAPEncodingPrefix;
-  static nsDependentString kXSIURI;
-  static nsDependentString kXSDURI;
-  static nsDependentString kXSIPrefix;
-  static nsDependentString kXSITypeAttribute;
-  static nsDependentString kXSDPrefix;
-  static nsDependentString kEncodingStyleAttribute;
-  static nsDependentString kActorAttribute;
-  static nsDependentString kEnvelopeTagName;
-  static nsDependentString kHeaderTagName;
-  static nsDependentString kBodyTagName;
-  static nsDependentString kFaultTagName;
-  static nsDependentString kFaultCodeTagName;
-  static nsDependentString kFaultStringTagName;
-  static nsDependentString kFaultActorTagName;
-  static nsDependentString kFaultDetailTagName;
-  static nsDependentString kEncodingSeparator;
-  static nsDependentString kQualifiedSeparator;
-  static nsDependentString kXMLNamespaceNamespaceURI;
-  static nsDependentString kXMLNamespaceURI;
-  static nsDependentString kXMLNamespacePrefix;
-  static nsDependentString kXMLPrefix;
-};
-
-//  Used to support null strings.
-
-inline PRBool AStringIsNull(const nsAReadableString& aString)
-{
-  return aString.IsVoid() || aString.IsEmpty(); // Get rid of empty hack when string implementations support.
-}
-
-inline void SetAStringToNull(nsAWritableString& aString)
-{
-  aString.Truncate();
-  aString.SetIsVoid(PR_TRUE);
-}
-
-#define NS_SOAP_ENSURE_ARG_STRING(arg) \
-NS_ENSURE_FALSE(AStringIsNull(arg), NS_ERROR_INVALID_ARG)
-
-
-#endif

mozilla/extensions/xmlextras/soap/Makefile.in

@@ -1,31 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH           = ../../..
-topsrcdir       = @top_srcdir@
-srcdir          = @srcdir@
-VPATH           = @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS            = public src
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlextras/soap/makefile.win

@@ -1,26 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/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.org 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.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..
-
-DIRS=public src
-
-include <$(DEPTH)\config\rules.mak>

mozilla/extensions/xmlextras/soap/public/MANIFEST_IDL

@@ -1,19 +0,0 @@
-#
-# This is a list of local files which get copied to the mozilla:dist:idl directory
-#
-
-nsISOAPAttachments.idl
-nsISOAPCall.idl
-nsISOAPDecoder.idl
-nsISOAPEncoder.idl
-nsISOAPEncoding.idl
-nsISOAPFault.idl
-nsISOAPHeaderBlock.idl
-nsISOAPMessage.idl
-nsISOAPParameter.idl
-nsISOAPResponse.idl
-nsISOAPResponseListener.idl
-nsISOAPService.idl
-nsISOAPServiceRegistry.idl
-nsISOAPTransport.idl
-nsISOAPTransportListener.idl

mozilla/extensions/xmlextras/soap/public/Makefile.in

@@ -1,50 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= xmlextras
-XPIDL_MODULE	= xmlsoap
-
-XPIDLSRCS	= \
-		nsISOAPAttachments.idl \
-		nsISOAPCall.idl \
-		nsISOAPDecoder.idl \
-		nsISOAPEncoder.idl \
-		nsISOAPEncoding.idl \
-		nsISOAPFault.idl \
-		nsISOAPHeaderBlock.idl \
-		nsISOAPMessage.idl \
-		nsISOAPParameter.idl \
-		nsISOAPResponse.idl \
-		nsISOAPResponseListener.idl \
-		nsISOAPService.idl \
-		nsISOAPServiceRegistry.idl \
-		nsISOAPTransport.idl \
-		nsISOAPTransportListener.idl \
-		$(NULL)
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlextras/soap/public/makefile.win

@@ -1,46 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/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.org 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.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..\..
-
-MODULE		= xmlextras
-XPIDL_MODULE	= xmlsoap
-
-XPIDLSRCS =  \
-		.\nsISOAPAttachments.idl \
-		.\nsISOAPCall.idl \
-		.\nsISOAPDecoder.idl \
-		.\nsISOAPEncoder.idl \
-		.\nsISOAPEncoding.idl \
-		.\nsISOAPFault.idl \
-		.\nsISOAPHeaderBlock.idl \
-		.\nsISOAPMessage.idl \
-		.\nsISOAPParameter.idl \
-		.\nsISOAPResponse.idl \
-		.\nsISOAPResponseListener.idl \
-		.\nsISOAPService.idl \
-		.\nsISOAPServiceRegistry.idl \
-		.\nsISOAPTransport.idl \
-		.\nsISOAPTransportListener.idl \
-	        $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-

mozilla/extensions/xmlextras/soap/public/nsISOAPAttachments.idl

@@ -1,50 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-/**
- * This interface permits attachment of SOAP attachments.
- */
-
-[scriptable, uuid(6192dcbe-1dd2-11b2-81ad-a4597614c4ae)]
-interface nsISOAPAttachments : nsISupports {
-
-/**
- * Get the attachment associated with a particular identifier.
- *
- * @param aIdentifier The identifier of the attachment to be accessed.
- *
- * Appropriate return(s) must be identified.
- */
-void getAttachment(in AString aIdentifier);
-
-/**
- * Attach an attachment to the message.
- *
- * Appropriate argument(s) must be identified.
- *
- * @return The identifier of the attachment, to be referenced in SOAP encoding
- */
-AString attach();
-
-};

mozilla/extensions/xmlextras/soap/public/nsISOAPCall.idl

@@ -1,90 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-#include "nsISOAPMessage.idl"
-
-interface nsISOAPResponse;
-interface nsISOAPResponseListener;
-
-/**
- * This interface is a convenience extension of the basic SOAP message,
- * which handles common patterns of calling, such as providing an
- * action URI in the HTTP header, locating and invoking the appropriate
- * transport based upon the protocol of the transportURI, and
- * automatically recieving the result in a new nsISOAPResponse object
- * which recieves an XML message.
- */
-
-[scriptable, uuid(a8fefe40-52bc-11d4-9a57-000064657374)]
-interface nsISOAPCall : nsISOAPMessage {
-
-  /**
-   * The URI to which the message will be sent, identifying the
-   *   transport and transport-specific information about the
-   *   destination.
-   * This does not have to match the <code>targetObjectURI</code>.
-   */
-  attribute AString transportURI;
-
-  /**
-   * Synchronously invoke the call. The method returns only when 
-   * we receive a response (or an error occurs).  The
-   * <code>transportURI</code> must have been set, the 
-   * parameter list (even if empty) must have been encoded,
-   * and the transportURI must use some known protocol.  A
-   * synchronous call assumes that there will be exactly one
-   * response per call.
-   *
-   * If not, an error is returned in the status of the response.
-   *
-   * @returns The SOAP response
-   */ 
-  nsISOAPResponse invoke();
-  
-  /**
-   * Asynchronously invoke the call. At this point, the document
-   * rooted by the Envelope element is encoded to form the body
-   * of the SOAP message. The method returns immediately, and the
-   * listener is invoked when we eventually receive a response
-   * (or error or successful completion). The
-   * <code>transportURI</code> must have been set, the 
-   * parameter list (even if empty) must have been encoded,
-   * and the transportURI must use some known protocol.
-   *
-   * If not, an error is returned in the status of the response.
-   *
-   * @param aListener Handler to be invoked asynchronously after the
-   *  response is recieved.  Should be null if no response is
-   *  expected.
-   */
-  void asyncInvoke(in nsISOAPResponseListener aListener);
-};
-
-%{ C++
-#define NS_SOAPCALL_CID                             \
-{ /* 87d21ec0-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec0, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPCALL_CONTRACTID \
-"@mozilla.org/xmlextras/soap/call;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPDecoder.idl

@@ -1,61 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISchemaType;
-interface nsISOAPEncoding;
-interface nsIDOMElement;
-interface nsIVariant;
-interface nsISOAPAttachments;
-
-/**
- * This interface supplies decoding of a specific
- * part of a message XML DOM into appropriate objects
- * for the script or application.
- */
-
-[scriptable, uuid(4c2e02ae-1dd2-11b2-b1cd-c79dea3d46db)]
-interface nsISOAPDecoder : nsISupports {
-
-/**
- * Decode the source DOM node
- *
- * @param aEncodings The encodings used to decode
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The DOM node to be decoded.
- *
- * @param aSchemaType The schema type of the source DOM node
- *
- * @param aAttachments Dispenses any attachments.
- *
- * @return The decoded variant, which is null if 
- *   the operation failed or did not return a result.
- */
-nsIVariant decode(
-    in nsISOAPEncoding aEncoding, 
-    in nsIDOMElement aSource, 
-    in nsISchemaType aSchemaType,
-    in nsISOAPAttachments aAttachments);
-};

mozilla/extensions/xmlextras/soap/public/nsISOAPEncoder.idl

@@ -1,69 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISchemaType;
-interface nsISOAPEncoding;
-interface nsIVariant;
-interface nsIDOMElement;
-interface nsISOAPAttachments;
-
-/**
- * This interface permits encoding of variants.
- */
-
-[scriptable, uuid(fc33ffd6-1dd1-11b2-8750-fa62430a38b4)]
-interface nsISOAPEncoder : nsISupports {
-
-/**
- * Encode the source variant.
- *
- * @param aEncodings The encodings to be used.
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The variant to be encoded.
- *
- * @param aNamespaceURI The namespace of the thing being coded
- *
- * @param aName The name of the thing being coded
- *
- * @param aSchemaType The schema type of the thing being encoded
- *
- * @param aDestination The node scope, if any, where the result 
- *   will live.  If this is null, then the result must be 
- *   explicitly attached to the message.
- *
- * @return element which was inserted.
- *
- * @param aAttachments Accumulates any attachments.
- */
-nsIDOMElement encode(
-    in nsISOAPEncoding aEncoding, 
-    in nsIVariant aSource, 
-    in AString aNamespaceURI, 
-    in AString aName, 
-    in nsISchemaType aSchemaType,
-    in nsISOAPAttachments aAttachments,
-    in nsIDOMElement aDestination);
-};

mozilla/extensions/xmlextras/soap/public/nsISOAPEncoding.idl

@@ -1,184 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISchemaType;
-interface nsIDOMElement;
-interface nsISOAPEncoder;
-interface nsISOAPDecoder;
-interface nsISOAPMessage;
-interface nsIVariant;
-interface nsISOAPAttachments;
-interface nsISchemaCollection;
-
-/**
- * This interface keeps track of all the known types and how
- *   each should be encoded (by type) or decoded (by 
- *   schema type)
- */
-
-[scriptable, uuid(9ae49600-1dd1-11b2-877f-e62f620c5e92)]
-interface nsISOAPEncoding : nsISupports {
-
-/**
- * The name of the encoding as it is known to SOAP.
- */
-  readonly attribute AString styleURI;
-
-/**
- * Get an alternative encoding.
- *
- * @param aStyleURI The style URI of the alternative encoding style.
- *
- * @param aCreateIf If true, then create the alternative style if it
- *   does not already exist, otherwise return the existing encoding.
- *
- * @return The alternative encoding which corresponds to the
- *   specified styleURI, or null if the spefied alternative encoding
- *   does not exist and it was not requested that it be created.
- */
-  nsISOAPEncoding getStyle(
-    in AString aStyleURI,
-    in boolean aCreateIf);
-
-/**
-  * Set an encoder in the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @param aEncoder The encoder to be specified or null to eliminate
-  *   the encoder.
-  *
-  * @return Old encoder registered under that type in the encoding, which
-  *   should be kept by the new encoder if it is to be called back.
-  */
-  void setEncoder(in AString aSchemaNamespaceURI, in AString aSchemaType, 
-   in nsISOAPEncoder aEncoder);
-
-/**
-  * Get an encoder from the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @return The encoder.
-  */
-  nsISOAPEncoder getEncoder(in AString aSchemaNamespaceURI, in AString aSchemaType);
-
-/**
-  * Set a decoder in the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @param aDecoder The decoder to be specified or null to eliminate
-  *   the decoder.
-  *
-  * @return Old decoder registered under that type in the encoding, which
-  *   should be kept by the new decoder if it is to be called back.
-  */
-  void setDecoder(in AString aSchemaNamespaceURI, in AString aSchemaType, 
-   in nsISOAPDecoder aDecoder);
-
-/**
-  * Get a decoder from the encoding.
-  *
-  * @param aSchemaNamespaceURI The schema namespace URI to serve as key.
-  *
-  * @param aSchemaType The schema type to serve as key.
-  *
-  * @return The decoder.
-  */
-  nsISOAPDecoder getDecoder(in AString aSchemaNamespaceURI, in AString aSchemaType);
-
-  attribute nsISOAPEncoder defaultEncoder;
-
-  attribute nsISOAPDecoder defaultDecoder;
-
-  attribute nsISchemaCollection schemaCollection;
-
-/**
- * Encode the source variant
- *
- * @param aEncodings The encodings to be used.
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The variant to be encoded, soon to become a variant
- *
- * @param aNamespaceURI The namespace of the thing being coded
- *
- * @param aName The name of the thing being coded
- *
- * @param aSchemaType The schema type of the thing being encoded
- *
- * @param aDestination The node scope where the result will live.
- *
- * @param aAttachments Accumulates any attachments.
- *
- * @return The element which was inserted and encoded.
- */
-  nsIDOMElement encode(
-      in nsIVariant aSource, 
-      in AString aNamespaceURI,
-      in AString aName,
-      in nsISchemaType aSchemaType,
-      in nsISOAPAttachments aAttachments,
-      in nsIDOMElement aDestination);
-
-/**
- * Decode the source DOM node
- *
- * @param aEncodings The encodings used to decode
- *
- * @param aEncodingStyleURI The encoding style
- *
- * @param aSource The DOM node to be decoded.
- *
- * @param aSchemaType The schema type of the source DOM node
- *
- * @param aAttachments Dispenses any attachments.
- *
- * @return The decoded variant, soon to become a variant, which is null if 
- *   the operation failed or did not return a result.
- */
-  nsIVariant decode(
-      in nsIDOMElement aSource, 
-      in nsISchemaType aSchemaType,
-      in nsISOAPAttachments aAttachments);
-};
-
-%{ C++
-#define NS_DEFAULTSOAPENCODER_CID                            \
-{ /* 06fb035c-1dd2-11b2-bc30-f6d8e314d6b9 */        \
-  0x06fb035c, 0x1dd2, 0x11b2,                       \
- {0xbc, 0x30, 0xf6, 0xd8, 0xe3, 0x14, 0xd6, 0xb9} }
-#define NS_SOAPENCODING_CONTRACTID_PREFIX \
-"@mozilla.org/xmlextras/soap/encoding;1?uri="
-#define NS_DEFAULTSOAPENCODER_CONTRACTID \
-NS_SOAPENCODING_CONTRACTID_PREFIX "http://schemas.xmlsoap.org/soap/encoding/"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPFault.idl

@@ -1,69 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-
-/**
- * This interface conveniently interprets information about a fault 
- * that has been returned in a response message.
- *
- */
-
-[scriptable, uuid(99ec6694-535f-11d4-9a58-000064657374)]
-interface nsISOAPFault : nsISupports {
-  /**
-   * The DOM element representing the fault in the response SOAP message.
-   * This must be set for the rest of the interface to function correctly.
-   */
-  attribute nsIDOMElement element;
-
-  /**
-   * The fault code
-   */
-  readonly attribute AString faultCode;
-
-  /**
-   * The fault string
-   */
-  readonly attribute AString faultString;
-  
-  /**
-   * The fault actor if one was specified.
-   */
-  readonly attribute AString faultActor;
-
-  /**
-   * The DOM element representing the fault details
-   */
-  readonly attribute nsIDOMElement detail;
-};
-
-%{ C++
-#define NS_SOAPFAULT_CID                            \
-{ /* 87d21ec1-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec1, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPFAULT_CONTRACTID \
-"@mozilla.org/xmlextras/soap/fault;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPHeaderBlock.idl

@@ -1,96 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-interface nsIVariant;
-interface nsISOAPEncoding;
-interface nsISchemaType;
-interface nsISOAPAttachments;
-
-/**
- * This interface encapsulates an arbitrary header block to be used
- * by the soap serialization or protocol.  It formalizes a type
- * string, a reference to the object, and a name.
- */
-
-[scriptable, uuid(063d4a4e-1dd2-11b2-a365-cbaf1651f140)]
-interface nsISOAPHeaderBlock : nsISupports {
-    
-  /**
-   * The namespace URI of the header block.  Ignored if name is null.
-   */
-  attribute AString namespaceURI;
-    
-  /**
-   * The name of the header block. If the header block is left unnamed, it
-   * will be encoded using the element types defined in the SOAP-ENC
-   * schema. For example, <code>&lt;SOAP-ENC:int&gt;45&lt;/SOAP-ENC:int&gt;
-   * </code>
-   */
-  attribute AString name;
-
-  /**
-   * The actor URI of the header block.
-   */
-  attribute AString actorURI;
-
-  /**
-   * The encoding that was / will be applied to the
-   * header block.
-   */
-  attribute nsISOAPEncoding encoding;
-
-  /**
-   * The schema type used to encode or decode the
-   *   header block.
-   */
-  attribute nsISchemaType schemaType;
-
-  /**
-   *  The element which is the encoded value of this header block.
-   *  If this is set, value becomes a computed attribute
-   *  which is produced by decoding this element.
-   */
-  attribute nsIDOMElement element;
-
-  /**
-   *  The native value which is the decoded value of 
-   *  this header block.  If this is set, element becomes null.
-   */
-  attribute nsIVariant value;
-
-  /**
-   * The attachments which were attached to the message.
-   */
-  attribute nsISOAPAttachments attachments;
-};
-
-%{ C++
-#define NS_SOAPHEADERBLOCK_CID                        \
-{ /* 5ad0eace-1dd2-11b2-a260-ff42edcaedb3 */        \
-  0x5ad0eace, 0x1dd2, 0x11b2,                       \
- {0xa2, 0x60, 0xff, 0x42, 0xed, 0xca, 0xed, 0xb3} }
-#define NS_SOAPHEADERBLOCK_CONTRACTID \
-"@mozilla.org/xmlextras/soap/headerblock;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPMessage.idl

@@ -1,196 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMDocument;
-interface nsIDOMElement;
-interface nsISOAPEncoding;
-interface nsISOAPHeaderBlock;
-interface nsISOAPParameter;
-interface nsIVariant;
-
-/**
- * This interface controls all SOAP messages. It permits easy
- * construction of a message, typically through encoding of
- * parameters and certain properties settable on this interface
- * or through deserialization of a transport stream.  It
- * permits easy processing of a message typically through
- * decoding of parameters and certain properties available
- * on this interface.  It also encapsulates protocol information
- * interpreted by the transport.
- */
-
-[scriptable, uuid(3970815e-1dd2-11b2-a475-db4dac6826f1)]
-interface nsISOAPMessage : nsISupports {
-  /**
-   * The document which captures the message, if any.  A simple 
-   * sending application passes parameters to the method
-   * encodeSOAPParameters, which calls SOAP encoders 
-   * to construct this document along with all contained elements.  
-   *
-   * But an application may create and set the message directly
-   * instead of invoking encodeSOAPParameters to use encoders
-   * or access and manipulate the message after it has been 
-   * constructed by encodeSOAPParameters.  If the message has 
-   * not been set, invoking a call will fail.  A message reciever 
-   * may also use this accessor to get the document to avoid using 
-   * decoders.
-   */
-  attribute nsIDOMDocument message;
-
-  /**
-   * A convenience attribute to obtain the DOM element representing the
-   * SOAP envelope from the document.  DOM methods may be used to 
-   * access, add, or modify attributes of the envelope.
-   *
-   * If the message attribute is null or is not a document containing
-   * a root soap envelope element, then this will be null.
-   */
-  readonly attribute nsIDOMElement envelope;
-
-  /**
-   * A convenience attribute to obtain the DOM element representing the
-   * SOAP header from the envelope.  DOM methods may be used to 
-   * access, add, or modify attributes or elements of the header.
-   *
-   * If the envelope attribute is null or does not contain a SOAP header
-   * element type, then this will be null.
-   */
-  readonly attribute nsIDOMElement header;
-
-  /**
-   * A convenience attribute to obtain the DOM element representing the
-   * SOAP body from the envelope.  DOM methods may be used to 
-   * access, add, or modify attributes or elements of the body.
-   *
-   * If the envelope attribute is null or does not contain a SOAP body
-   * element type, then this will be null.
-   */
-  readonly attribute nsIDOMElement body;
-
-  /**
-   * The name of the method being invoked. The methodName is set
-   * during encoding as the tagname of the single child of body
-   * of RPC-style messages.  When there is no encoded message
-   * this will be null.  The value of this attribute for
-   * document-style messages may be non-null but should be
-   * ignored.  It is up to the application to know whether the
-   * message is RPC-style or document style because the SOAP
-   * specification makes it difficult to tell which way a
-   * message was encoded.
-   */
-  readonly attribute AString methodName;   
-
-  /**
-   * The target object on which the method is being invoked. This URI
-   * is set during encoding as the namespace to qualify the tagname 
-   * of the single child of body of RPC-style messages.  When there
-   * is no encoded message, this will be null.  The value of this
-   * attribute for document-style messages may be non-null but should
-   * be ignored.  It is up to the application to know whether the
-   * message is RPC-style or document style because the SOAP
-   * specification makes it difficult to tell which way a
-   * message was encoded.
-   */
-  readonly attribute AString targetObjectURI;
-
-  /**
-   * Encodes the specified parameters into this message, if
-   * this message type supports it.
-   *
-   * @param aMethodName The name of the method being invoked
-   * for rpc-style messages.  For document-style messages,
-   * this must be null.
-   *
-   * @param aTargetObjectURI The name of the target object
-   * for rpc-style messages.  For document-style messages,
-   * this must be null.
-   *
-   * @param aHeaderBlockCount Number of header blocks in array to be
-   *   encoded.  Must be 0 if header block array is null.
-   *
-   * @param aHeaderBlocks Array of header blocks to be encoded, which
-   *   may be null if there are no header blocks.
-   *
-   * @param aParameterCount Number of parameters in array 
-   *   to be encoded.  Must be 0 if parameter array is null.
-   *
-   * @param aParameters An array of parameters to be 
-   *   encoded, which may null if there are no parameters.
-   */
-  void encode(
-    in AString aMethodName, in AString aTargetObjectURI,
-    in PRUint32 aHeaderBlockCount, 
-    [array, size_is(aHeaderBlockCount)] in nsISOAPHeaderBlock aHeaderBlocks,
-    in PRUint32 aParameterCount, 
-    [array, size_is(aParameterCount)] in nsISOAPParameter aParameters);
-
-  /**
-   * Gathers the header blocks of a message so that they can be
-   *   accessed by a recipient.
-   *
-   * @param aCount Integer to receive the length of the list
-   *   of header blocks.
-   *
-   * @return Array of header blocks found in the message.
-   */
-  void getHeaderBlocks(out PRUint32 aCount,
-    [array, size_is(aCount), retval] out nsISOAPHeaderBlock aHeaderBlocks);
-
-  /**
-   * Gathers the parameters of a message so that they can be
-   *   accessed by a recipient.
-   *
-   * @param aDocumentStyle If true, then the parameters
-   *   are looked for treating the message as a document 
-   *   style message, otherwise it treated as an RPC-style 
-   *   message.
-   *
-   * @param aCount Integer to receive the length of the list
-   *   of parameters.
-   *
-   * @return Array of parameters found in the message.
-   */
-  void getParameters(in boolean aDocumentStyle,
-    out PRUint32 aCount, 
-    [array, size_is(aCount), retval] out nsISOAPParameter aParameters);
-
-  /**
-   * The primary encoding of the message, which is established
-   *   at the envelope and used unless overridden.  By default,
-   *   this is the SOAP encoding, which may be locally modified
-   *   or used to obtain alternative encodings, which may be
-   *   locally modified, but it may be set to an encoding that
-   *   is shared, or it may be set to null, in which case all
-   *   non-literal header blocks and parameters must specify an
-   *   encoding.
-   */
-  attribute nsISOAPEncoding encoding;
-
-  /**
-   * An optional URI that can be used to add a SOAPAction HTTP
-   * header field. If this attribute is NULL (the default case),
-   * no SOAPAction header will be added.
-   */
-  attribute AString actionURI;
-};

mozilla/extensions/xmlextras/soap/public/nsISOAPParameter.idl

@@ -1,93 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-interface nsIVariant;
-interface nsISOAPEncoding;
-interface nsISchemaType;
-interface nsISOAPAttachments;
-
-/**
- * This interface encapsulates an arbitrary parameter to be used
- * by the soap serialization or protocol.  It formalizes a type
- * string, a reference to the object, and a name.
- */
-
-[scriptable, uuid(99ec6690-535f-11d4-9a58-000064657374)]
-interface nsISOAPParameter : nsISupports {
-    
-  /**
-   * The namespace URI of the parameter.  Ignored if name is null.
-   */
-  attribute AString namespaceURI;
-    
-  /**
-   * The name of the parameter. If the parameter is left unnamed, it
-   * will be encoded using the element types defined in the SOAP-ENC
-   * schema. For example, <code>&lt;SOAP-ENC:int&gt;45&lt;/SOAP-ENC:int&gt;
-   * </code>
-   */
-  attribute AString name;
-
-  /**
-   * The encoding that was / will be applied to the
-   * parameter.
-   */
-  attribute nsISOAPEncoding encoding;
-
-  /**
-   * The schema type used to encode or decode the
-   *   parameter.
-   */
-  attribute nsISchemaType schemaType;
-
-  /**
-   *  The element which is the encoded value of this parameter.
-   *  If this is set, value becomes a computed attribute
-   *  which may be produced by decoding this element.
-   */
-  attribute nsIDOMElement element;
-
-  /**
-   *  The native value which is the decoded value of 
-   *  this parameter.  If this is set, element becomes
-   *  null.
-   */
-  attribute nsIVariant value;
-
-  /**
-   * The attachments which were attached to the message
-   *   that may be needed to decode the parameter.
-   */
-  attribute nsISOAPAttachments attachments;
-};
-
-%{ C++
-#define NS_SOAPPARAMETER_CID                        \
-{ /* 87d21ec2-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec2, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPPARAMETER_CONTRACTID \
-"@mozilla.org/xmlextras/soap/parameter;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPResponse.idl

@@ -1,63 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-#include "nsISOAPCall.idl"
-
-interface nsISOAPParameter;
-interface nsISOAPFault;
-
-/**
- * This is an extension of a message which contains extra functions
- * such as tracking, where appropriate, the original call that
- * produced the response message, identifying the fault, if any,
- * and supplying the return value.
- */
-
-[scriptable, uuid(99ec6691-535f-11d4-9a58-000064657374)]
-interface nsISOAPResponse : nsISOAPMessage {
-  /**
-   * The message which generated this response.  There is no guarantee
-   *   that the message has not been modified since the original call
-   *   occurred.  This is set automatically when invoking a call that
-   *   returns this response.  This must also be set by a call processor
-   *   so that the transport can return a response to the correct caller.
-   */
-  attribute nsISOAPCall respondingTo;
-
-  /**
-   * The fault returned in the response, if one was generated. NULL
-   * if there was no fault.  This does not rely on the response
-   * parameters having been deserialized.
-   */
-  readonly attribute nsISOAPFault fault;
-
-};
-
-%{ C++
-#define NS_SOAPRESPONSE_CID                         \
-{ /* 87d21ec3-539d-11d4-9a59-00104bdf5339 */        \
-  0x87d21ec3, 0x539d, 0x11d4,                       \
- {0x9a, 0x59, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_SOAPRESPONSE_CONTRACTID \
-"@mozilla.org/xmlextras/soap/response;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPResponseListener.idl

@@ -1,61 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISOAPCall;
-interface nsISOAPResponse;
-
-/**
- * This interface represents a response handler to be invoked whenever
- * a response of a particular call is recieved and when no more
- * responses are expected.
- */
-
-[scriptable, uuid(99ec6692-535f-11d4-9a58-000064657374)]
-interface nsISOAPResponseListener : nsISupports {
-  /**
-   * This method is invoked when we receive an asynchronous response to 
-   * a SOAP message. The listener is registered as part of the original
-   * asynchronous call invocation. 
-   *
-   * @param aResponse The decoded version of the response.  If an
-   *   error occurred transmitting the response, the status field
-   *   of the response will contain an error code.  The last call
-   *   to the listener may contain a null response, which should
-   *   only be interpreted as an error if your call expected more 
-   *   results than it got.  If the service or the transport
-   *   do not know whether to expect more results, then setting
-   *   the last parameter true may only be possible after the
-   *   last response has already been delivered.
-   *
-   * @param aLast True if this is the last call to the listener.
-   *
-   * @return True to make this the last call to the listener, even
-   *   if last was not true.  Calls which expect a single response
-   *   should return true upon receiving that response to avoid
-   *   possibly recieving another callback with a null response
-   *   indicating that the last response was already sent.
-   */ 
-  boolean handleResponse(in nsISOAPResponse aResponse, 
-    in nsISOAPCall aCall, in unsigned long status, in boolean aLast);
-};

mozilla/extensions/xmlextras/soap/public/nsISOAPService.idl

@@ -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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISOAPMessage;
-interface nsISOAPResponseListener;
-
-/**
- * This interface describes a service which may be
- *   applied to incoming messages.  The service is
- *   responsible for determining whether the message
- *   is one that it should process and rejecting it
- *   if it is not.  Services may be chained.
- */
-[scriptable, uuid(9927fa40-1dd1-11b2-a8d1-857ad21b872c)]
-interface nsISOAPService : nsISupports {
-/**
- * Configuration object that may contain more info on the service
- */
-  attribute nsISupports configuration;
-
-/**
- * Process an incoming message.
- *
- * @param aMessage message to be processed
- *
- * @param aListener listener to which to report results
- *
- * @return True if the message will be handled, false if
- *   it should be given to some other service or fail.
- *   In case of failure, a more detailed status will be
- *   recorded in the message.
- */
-  boolean process(in nsISOAPMessage aMessage, 
-    in nsISOAPResponseListener aListener);
-};
-
-%{ C++
-#define NS_SOAPJSSERVICE_CID                            \
-{ /* 26a41df2-1dd2-11b2-9f29-909e637afa0e */        \
-  0x26a41df2, 0x1dd2, 0x11b2,                       \
- {0x9f, 0x29, 0x90, 0x9e, 0x63, 0x7a, 0xfa, 0x0e} }
-#define NS_SOAPJSSERVICE_CONTRACTID \
-"@mozilla.org/xmlextras/soap/jsservice;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPServiceRegistry.idl

@@ -1,93 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMElement;
-interface nsISOAPService;
-interface nsISOAPEncodingRegistry;
-
-/**
- * This interface represents a registry of SOAP services.
- * This registry recieves transports to listen for messages
- *   and services to hand the messages to.  Service registries
- *   may be created as required.  Destroying a service registry
- *   stops the registry's action.  To temporarily register
- *   services, create a new registry.  For proper order of
- *   listening precedence, registries should be destroyed
- *   in reverse order.  Otherwise, a listening priority
- *   would be required.
- */
-[scriptable, uuid(9790d6bc-1dd1-11b2-afe0-bcb310c078bf)]
-interface nsISOAPServiceRegistry {
-/**
- * Process a configuration and add the resulting sources
- *   and services.  This will fail if errors occur during
- *   processing of the configuration.
- *
- * @param aConfiguration Root element of configuration XML.
- */
-  boolean addConfiguration(in nsIDOMElement aConfiguration);
-
-/**
- * Add a transport to be serviced by the registered services.
- *   This will fail if the specified source was already added
- *   with the same setting of the capture flag.
- *
- * @param aTransport string specifying the transport to supply
- *   messages for the service.
- *
- * @param aCapture True if capturing before later declarations
- */
-  void addSource(in AString aTransport, in boolean aCapture);
-
-/**
- * Add a service to service the registered transports.  This
- *   will fail if the specified service was already added.
- *
- * @param aService Service to be serviced.
- */
-  void addService(in nsISOAPService aService);
-
-/**
- * Registry identifying how to encode and decode
- *   messages containing specific types, automatically
- *   added to messages sent to services in this
- *   registry.
- */
-  attribute nsISOAPEncodingRegistry encodings;
-};
-
-%{ C++
-#define NS_SOAPSERVICEREGISTRY_CID                            \
-{ /* 3869184e-1dd2-11b2-aa36-d8333498043a */        \
-  0x3869184e, 0x1dd2, 0x11b2,                       \
- {0xaa, 0x36, 0xd8, 0x33, 0x34, 0x98, 0x04, 0x3a} }
-#define NS_SOAPSERVICEREGISTRY_CONTRACTID \
-"@mozilla.org/xmlextras/soap/serviceregistry;1"
-#define NS_SOAPDEFAULTSERVICEREGISTRY_CID                            \
-{ /* 9120a01e-1dd2-11b2-a61f-906766927a4f */        \
-  0x9120a01e, 0x1dd2, 0x11b2,                       \
- {0xa6, 0x1f, 0x90, 0x67, 0x66, 0x92, 0x7a, 0x4f} }
-#define NS_SOAPDEFAULTSERVICEREGISTRY_CONTRACTID \
-"@mozilla.org/xmlextras/soap/defaultserviceregistry;1"
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPTransport.idl

@@ -1,102 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsISOAPTransportListener;
-interface nsISOAPCall;
-interface nsISOAPResponse;
-interface nsISOAPResponseListener;
-
-[scriptable, uuid(99ec6695-535f-11d4-9a58-000064657374)]
-interface nsISOAPTransport : nsISupports {
-
-/**
- * Send the specified message to the specified destination.
- * This will fail if synchronous calls are not supported or if there is any
- * failure in the actual message exchange.  Failure of the call itself will be
- * contained in the response.
- *
- * @param aCall Actual message to be sent.
- *
- * @param aResponse Message to be recieved.  Calling synchronously assumes that 
- *   exactly one response is expected.
- */
-  void syncCall( in nsISOAPCall aCall,
-                 in nsISOAPResponse aResponse);
-
-/**
- * Send the specified message to the specified destination synchronously waiting 
- * for completion and any response.
- * This will fail if there is any failure in the setup of the message exchange.
- * Later errors will only be known through the response listener.  Failures of the
- * call itself will be contained in the response passed to the response listener.
- *
- * @param aCall Actual message to be sent.
- *
- * @param aListener Handler to be invoked (single threaded) as each response is 
- *  received and finally with null.  If specified as null, no responses are returned.
- *
- * @param response Message to recieve response and be handled by listener.  May be 
- *   null if listener is null.
- */
-  void asyncCall(in nsISOAPCall aCall,
-                 in nsISOAPResponseListener aListener,
-                 in nsISOAPResponse aResponse);
-
-/**
- * Add listener for unsolicited messages arriving on the transport.  Listeners
- *  are provided with the opportunity to accept and process messages.  Typically
- *  a listener will be a service dispatcher.  Listeners will be invoked in the
- *  reverse order of declaration, allowing more local service dispatchers to
- *  temporarily override permanent service dispatchers.  This will fail if the
- *  desired listener was already added to the transport with the specified
- *  capture flag or if the transport does not support incoming messages.
- *
- * @param aListener The listener to recieve unsolicited messages from the
- *   transport.
- *
- * @param aCapture True if the listener should capture the message before
- *   later-declared services.
- */
-  void addListener(in nsISOAPTransportListener aListener, in boolean aCapture);
-
-/**
- * Remove listener for unsolicited messages arriving on the transport.  This
- *  will fail if the specified listener was not added with the specified
- *  capture setting.
- *
- * @param aListener The listener to stop from recieving unsolicited messages 
- *  from the transport.
- *
- * @param aCapture True if the listener was added to capture the message before
- *   later-declared services (must be specified to remove, since a listener
- *   may be registered as both).
- */
-  void removeListener(in nsISOAPTransportListener aListener, in boolean aCapture);
-};
-
-%{ C++
-#define NS_SOAPTRANSPORT_CONTRACTID  \
-"@mozilla.org/xmlextras/soap/transport;1"
-#define NS_SOAPTRANSPORT_CONTRACTID_PREFIX   NS_SOAPTRANSPORT_CONTRACTID "?protocol="
-%}

mozilla/extensions/xmlextras/soap/public/nsISOAPTransportListener.idl

@@ -1,50 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org code.
- *
- * The Initial Developer of the Original Code is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation. All
- * Rights Reserved.
- *
- * Contributor(s): 
- */
-
-#include "nsISupports.idl"
-
-interface nsIDOMDocument;
-interface nsISOAPMessage;
-
-/**
- * This interface recieves control when an unsolicited transport
- * is recieved on a transport.
- */
-
-[scriptable, uuid(99ec6696-535f-11d4-9a58-000064657374)]
-interface nsISOAPTransportListener : nsISupports {
-
-  /**
-   * This method is invoked when an unsolicited message is
-   *   recieved.  First all listeners are tried in the order declared
-   *   with the capture flag set.  Then all listeners are tried in
-   *   the reverse order declared with the capture flag clear.
-   *
-   * @param aMessage Actual message.
-   *
-   * @param aCapture True if the listener is being permitted to gain
-   *   control before all later-added listeners.
-   *
-   * @return true if message is handled, false if it was not
-   */
-  boolean handleMessage(in nsISOAPMessage aMessage, in boolean aCapture);
-};

mozilla/extensions/xmlextras/soap/src/Makefile

@@ -1,52 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../../..
-topsrcdir	= ../../../..
-srcdir		= .
-VPATH		= .
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= xmlextras
-LIBRARY_NAME	= xmlextrassoap_s
-REQUIRES	= xpcom string caps dom js widget layout xpconnect necko
-
-CPPSRCS	= 				\
-		nsSOAPCall.cpp	        \
-		nsDefaultSOAPEncoder.cpp\
-		nsSOAPFault.cpp	        \
-		nsSOAPHeaderBlock.cpp	\
-		nsSOAPJSValue.cpp	\
-		nsSOAPMessage.cpp	\
-		nsSOAPParameter.cpp	\
-		nsSOAPResponse.cpp	\
-		nsSOAPStruct.cpp	\
-		nsSOAPUtils.cpp		\
-		nsSOAPEncodingRegistry.cpp		\
-		$(NULL)
-
-# 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/extensions/xmlextras/soap/src/Makefile.in

@@ -1,52 +0,0 @@
-# 
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-# 
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-# 
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-MODULE		= xmlextras
-LIBRARY_NAME	= xmlextrassoap_s
-REQUIRES	= xpcom string caps dom js widget xpconnect necko schema
-
-CPPSRCS	= 				\
-		nsDefaultSOAPEncoder.cpp\
-		nsHTTPSOAPTransport.cpp	\
-		nsSOAPCall.cpp	        \
-		nsSOAPEncoding.cpp	\
-		nsSOAPFault.cpp	        \
-		nsSOAPHeaderBlock.cpp	\
-		nsSOAPMessage.cpp	\
-		nsSOAPParameter.cpp	\
-		nsSOAPResponse.cpp	\
-		nsSOAPUtils.cpp		\
-		$(NULL)
-
-# we don't want the shared lib, but we want to force the creation of a
-# static lib.
-FORCE_STATIC_LIB = 1
-#override NO_SHARED_LIB=1
-#override NO_STATIC_LIB=
-
-include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlextras/soap/src/makefile.win

@@ -1,64 +0,0 @@
-#!nmake
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/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.org 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.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..\.. 
-
-LIBRARY_NAME=xmlextrassoap_s 
-MODULE=xmlextras
-
-REQUIRES	=  \
-    xpcom      \
-    string     \
-    caps       \
-    dom        \
-    js         \
-    widget     \
-    xpconnect  \
-    necko
-
-DEFINES=-D_IMPL_NS_HTML -DWIN32_LEAN_AND_MEAN
-
-OBJS=	\
-	.\$(OBJDIR)\nsDefaultSOAPEncoder.obj \
-	.\$(OBJDIR)\nsHTTPSOAPTransport.obj  \
-	.\$(OBJDIR)\nsSOAPCall.obj           \
-	.\$(OBJDIR)\nsSOAPEncoding.obj       \
-	.\$(OBJDIR)\nsSOAPFault.obj          \
-	.\$(OBJDIR)\nsSOAPHeaderBlock.obj    \
-	.\$(OBJDIR)\nsSOAPMessage.obj        \
-	.\$(OBJDIR)\nsSOAPParameter.obj      \
-	.\$(OBJDIR)\nsSOAPResponse.obj       \
-#	.\$(OBJDIR)\nsSOAPStruct.obj         \
-	.\$(OBJDIR)\nsSOAPUtils.obj          \
-	$(NULL)
-
-LCFLAGS = \
-        $(LCFLAGS) \
-        $(DEFINES) \
-        $(NULL)
-
-include <$(DEPTH)\config\rules.mak>
-
-libs:: $(LIBRARY)
-	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
-
-clobber::
-	rm -f $(DIST)\lib\$(LIBRARY_NAME).lib

mozilla/extensions/xmlextras/soap/src/nsDefaultSOAPEncoder.h

@@ -1,34 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsDefaultSOAPEncoder_h__
-#define nsDefaultSOAPEncoder_h__
-
-#include "nsSOAPEncoding.h"
-
-class nsDefaultSOAPEncoder : public nsSOAPEncoding
-{
-public:
-  nsDefaultSOAPEncoder();
-};
-
-#endif

mozilla/extensions/xmlextras/soap/src/nsHTTPSOAPTransport.cpp

@@ -1,196 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#include "nsHTTPSOAPTransport.h"
-#include "nsIComponentManager.h"
-#include "nsIDOMDocument.h"
-#include "nsString.h"
-#include "nsSOAPUtils.h"
-#include "nsSOAPCall.h"
-#include "nsSOAPResponse.h"
-#include "nsIDOMEventTarget.h"
-
-nsHTTPSOAPTransport::nsHTTPSOAPTransport()
-{
-  NS_INIT_ISUPPORTS();
-}
-
-nsHTTPSOAPTransport::~nsHTTPSOAPTransport()
-{
-}
-
-NS_IMPL_ISUPPORTS1_CI(nsHTTPSOAPTransport, nsISOAPTransport)
-
-/* void syncCall (in nsISOAPCall aCall, in nsISOAPResponse aResponse); */
-NS_IMETHODIMP nsHTTPSOAPTransport::SyncCall(nsISOAPCall *aCall, nsISOAPResponse *aResponse)
-{
-  NS_ENSURE_ARG(aCall);
-
-  nsresult rv;
-  nsCOMPtr<nsIXMLHttpRequest> request;
-
-  request = do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  nsAutoString action;
-  rv = aCall->GetActionURI(action);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(action)) {
-    rv = request->SetRequestHeader("SOAPAction", NS_ConvertUCS2toUTF8(action).get());
-    if (NS_FAILED(rv)) return rv;
-  }
-
-  nsAutoString uri;
-  rv = aCall->GetTransportURI(uri);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(uri)) return NS_ERROR_NOT_INITIALIZED;
-
-  nsCOMPtr<nsIDOMDocument> messageDocument;
-  rv = aCall->GetMessage(getter_AddRefs(messageDocument));
-  if (NS_FAILED(rv)) return rv;
-  if (!messageDocument) return NS_ERROR_NOT_INITIALIZED;
-
-  rv = request->OpenRequest("POST", NS_ConvertUCS2toUTF8(uri).get(), PR_FALSE, nsnull, nsnull);
-  if (NS_FAILED(rv)) return rv;
-			    
-  rv = request->Send(messageDocument);
-  if (NS_FAILED(rv)) return rv;
-
-  request->GetStatus(&rv);
-  if (NS_FAILED(rv)) return rv;
-
-  if (aResponse) {
-    nsCOMPtr<nsIDOMDocument> response;
-    rv = request->GetResponseXML(getter_AddRefs(response));
-    if (NS_FAILED(rv)) return rv;
-    rv = aResponse->SetMessage(response);
-    if (NS_FAILED(rv)) return rv;
-  }
-
-  return NS_OK;
-}
-
-class nsHTTPSOAPTransportCompletion : public nsIDOMEventListener
-{
-public:
-  nsHTTPSOAPTransportCompletion();
-  virtual ~nsHTTPSOAPTransportCompletion();
-
-  NS_DECL_ISUPPORTS
-
-  // nsIDOMEventListener
-  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent);
-
-protected:
-  nsCOMPtr<nsISOAPCall> mCall;
-  nsCOMPtr<nsISOAPResponse> mResponse;
-  nsCOMPtr<nsIXMLHttpRequest> mRequest;
-  nsCOMPtr<nsISOAPResponseListener> mListener;
-};
-
-NS_IMPL_ISUPPORTS1(nsHTTPSOAPTransportCompletion, nsIDOMEventListener)
-
-nsHTTPSOAPTransportCompletion::nsHTTPSOAPTransportCompletion()
-{
-  NS_INIT_ISUPPORTS();
-}
-nsHTTPSOAPTransportCompletion::~nsHTTPSOAPTransportCompletion()
-{
-}
-NS_IMETHODIMP
-nsHTTPSOAPTransportCompletion::HandleEvent(nsIDOMEvent* aEvent)
-{
-  nsresult rv;
-  mRequest->GetStatus(&rv);
-  if (NS_SUCCEEDED(rv)) {
-    nsCOMPtr<nsIDOMDocument> document;
-    rv = mRequest->GetResponseXML(getter_AddRefs(document));
-    if (NS_SUCCEEDED(rv)) {
-      rv = mResponse->SetMessage(document);
-    }
-  }
-  PRBool c;  //  In other transports, this may signal to stop returning if multiple returns
-  mListener->HandleResponse(mResponse, mCall, (PRInt32)rv, PR_TRUE, &c);
-  return NS_OK;
-}
-
-/* void asyncCall (in nsISOAPCall aCall, in nsISOAPResponseListener aListener, in nsISOAPResponse aResponse); */
-NS_IMETHODIMP nsHTTPSOAPTransport::AsyncCall(nsISOAPCall *aCall, nsISOAPResponseListener *aListener, nsISOAPResponse *aResponse)
-{
-  NS_ENSURE_ARG(aCall);
-
-  nsresult rv;
-  nsCOMPtr<nsIXMLHttpRequest> request;
-
-  nsCOMPtr<nsIDOMEventTarget> eventTarget = do_QueryInterface(request, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  request = do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv);
-  if (NS_FAILED(rv)) return rv;
-
-  nsAutoString action;
-  rv = aCall->GetActionURI(action);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(action)) {
-    rv = request->SetRequestHeader("SOAPAction", NS_ConvertUCS2toUTF8(action).get());
-    if (NS_FAILED(rv)) return rv;
-  }
-  nsCOMPtr<nsIDOMEventListener> listener = new nsHTTPSOAPTransportCompletion();
-  if (!listener) return NS_ERROR_OUT_OF_MEMORY;
-
-  nsAutoString uri;
-  rv = aCall->GetTransportURI(uri);
-  if (NS_FAILED(rv)) return rv;
-  if (!AStringIsNull(uri)) return NS_ERROR_NOT_INITIALIZED;
-
-  nsCOMPtr<nsIDOMDocument> messageDocument;
-  rv = aCall->GetMessage(getter_AddRefs(messageDocument));
-  if (NS_FAILED(rv)) return rv;
-  if (!messageDocument) return NS_ERROR_NOT_INITIALIZED;
-
-  rv = request->OpenRequest("POST", NS_ConvertUCS2toUTF8(uri).get(), PR_TRUE, nsnull, nsnull);
-  if (NS_FAILED(rv)) return rv;
-			    
-  rv = request->Send(messageDocument);
-  if (NS_FAILED(rv)) return rv;
-
-  eventTarget->AddEventListener(NS_LITERAL_STRING("load"), listener, PR_FALSE);
-  eventTarget->AddEventListener(NS_LITERAL_STRING("error"), listener, PR_FALSE);
-  
-  rv = request->Send(messageDocument);
-  if (NS_FAILED(rv)) return rv;
-
-  return NS_OK;
-}
-
-/* void addListener (in nsISOAPTransportListener aListener, in boolean aCapture); */
-NS_IMETHODIMP nsHTTPSOAPTransport::AddListener(nsISOAPTransportListener *aListener, PRBool aCapture)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* void removeListener (in nsISOAPTransportListener aListener, in boolean aCapture); */
-NS_IMETHODIMP nsHTTPSOAPTransport::RemoveListener(nsISOAPTransportListener *aListener, PRBool aCapture)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-

mozilla/extensions/xmlextras/soap/src/nsHTTPSOAPTransport.h

@@ -1,50 +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.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/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.org 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.
- *
- * Contributor(s): 
- */
-
-#ifndef nsHTTPSOAPTransport_h__
-#define nsHTTPSOAPTransport_h__
-
-#include "nsISOAPTransport.h"
-#include "nsIXMLHttpRequest.h"
-#include "nsIDOMEventListener.h"
-#include "nsISOAPTransportListener.h"
-#include "nsCOMPtr.h"
-
-class nsHTTPSOAPTransport : public nsISOAPTransport
-{
-public:
-  nsHTTPSOAPTransport();
-  virtual ~nsHTTPSOAPTransport();
-
-  NS_DECL_ISUPPORTS
-
-  // nsISOAPTransport
-  NS_DECL_NSISOAPTRANSPORT
-};
-
-#define NS_HTTPSOAPTRANSPORT_CID                   \
- { /* d852ade0-5823-11d4-9a62-00104bdf5339 */      \
- 0xd852ade0, 0x5823, 0x11d4,                       \
- {0x9a, 0x62, 0x00, 0x10, 0x4b, 0xdf, 0x53, 0x39} }
-#define NS_HTTPSOAPTRANSPORT_CONTRACTID NS_SOAPTRANSPORT_CONTRACTID_PREFIX "http"
-
-#endif