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/java/Makefile.in

@@ -1,38 +0,0 @@
-#!gmake
-# 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	= ..
-topsrcdir	= @top_srcdir@
-VPATH		= @srcdir@
-srcdir		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-# PENDING(edburns): make it so it's possible to just build
-# webclient and javadom
-
-DIRS=   util		\
-	dom		\
-	plugins		\
-	webclient	\
-	$(NULL)
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/java/Makefile.win

@@ -1,43 +0,0 @@
-#!nmake
-#
-# 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 Sun Microsystems,
-# Inc. Portions created by Sun are
-# Copyright (C) 1999 Sun Microsystems, Inc. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-IGNORE_MANIFEST=1 
-#//------------------------------------------------------------------------
-#//
-#// Makefile to build the java enhancers to mozilla
-#//
-#//------------------------------------------------------------------------
-
-
-#//------------------------------------------------------------------------
-#//
-#// Specify the depth of the current directory relative to the
-#// root of NS
-#//
-#//------------------------------------------------------------------------
-DEPTH = ..
-
-DIRS  = external \
-	util \
-	dom \
-	webclient 
-
-include <$(DEPTH)\config\rules.mak>

mozilla/java/README

@@ -1,36 +0,0 @@
-Here lies the code that comprises the java enhancers to mozilla.
-
-Authors: see the README files for each individual subdirectory
-
-Requirements:
-
-* JDK1.2 or greater (may work with lower versions, haven't checked).
-
-* Successfully built MOZ_DEBUG=1 Mozilla M13 tree.
-
-* Perl 5 perl.exe must be in your path
-
-How To Build:
-
-* make it so the directory in which this file resides is a child of your
-  top level Mozilla M13 directory
-
-* make sure the environment var JDKHOME is set to your jdk installation
-  directory, ie SET JDKHOME=C:\jdk1.2.2
-
-* type "nmake /f makefile.win all" and hope for the best
-
-* this should compile the clasess into %MOZ_SRC%\dist\classes
-
-Problems:
-
-* clobber_all doesn't remove the .class files from dist\classes.  You
-  have to do this manually.
-
-* post to netscape.public.mozilla.java newsgroup
-
-General notes:
-
-* Please update the ChangeLog (changelo) files in the subdirectories when
-  you make changes.
-

mozilla/java/README.commercial

@@ -1,106 +0,0 @@
-******************** BLACKWOOD RELEASE 0.9 README ********************
-
-
-READ THIS DOCUMENT BEFORE RUNNING ANY OF THE BLACKWOOD COMPONENTS
-
-
-This version of Blackwood has been built on and configured for
-the Solaris(TM) operating environment
-
-
-This package contains the following components of the Blackwood Project
-- Pluglets, JavaDOM and Webclient
-
-The Blackwood project aims to -
-1. Better integrate the Java (TM) platform with the Mozilla (Netscape 6) 
-   Browser so developers can extend the browser with components and
-   plug-ins written in the Java programming language
-2. Make sure that Mozilla's layout engine can be embedded in 
-   applications running on a Java virtual machine (JVM).
-
-More information on the Blackwood project can be obtained online at
-http://www.mozilla.org/projects/blackwood/
-
-
-------------------------------------------------------------------------
-SYSTEM REQUIREMENTS
-------------------------------------------------------------------------
-
-The Blackwood software components run on Solaris for SPARC(TM) and 
-Solaris for Intel with Solaris versions 7 and 8.
-
-You will also need to install the JRE1.3.0_01 Java Bundle that goes
-with Netscape 6 PR3
-
-
--------------------------------------------------------------------------
-BLACKWOOD COMPONENTS
--------------------------------------------------------------------------
-
-JAVA PLUGLET API - A Pluglet is a plug-in that is written in the Java 
-programming Language. The Java Pluglet API is a close 1:1 implementation
-of the new C++ Plug-in API in Mozilla and it allows users to develop 
-plug-ins in Java that run inside a Java Virtual Machione (JVM).
-
-More information can be obtained online at 
-http://www.mozilla.org/projects/blackwood/java-plugins/
-
-
-JAVA DOM API - The Java DOM API is an implementation of the Java Bindings
-specified in the Document Object Model (DOM) Level 1 Specification. This
-API allows Java Applets and Pluglets to interact with and modify the 
-document they are embedded into.
-
-More information can be obtained online at
-http://www.mozilla.org/projects/blackwood/dom/
-http://www.w3.org/TR/REC-DOM-Level-1/java-language-binding.html
-
-
-WEBCLIENT - Webclient is a browser-neutral Java API that enables generic 
-web browsing capabilities in a Java application.
-
-More information can be obtained online at
-http://www.mozilla.org/projects/blackwood/webclient/
-http://www.mozilla.org/projects/blackwood/webclient/ref_guides/Developer_guide/index.htm
-http://www.mozilla.org/projects/blackwood/webclient/ref_guides/Implementation_guide/index.htm
-
-
--------------------------------------------------------------------------
-RUN INSTRUCTIONS
--------------------------------------------------------------------------
-
-PLUGLETS 
-- Launch the browser using the shell script "netscape_pluglets"
-- Navigate to the url file:///<your_Netscape6_install_dir>/res/javadev/pluglets/test.html
-- If you wish to observe Mozilla debug messages on your shell prompt, launch Pluglets
-  using the script "netscape_debug_pluglets"
-  
-This contains several Pluglet examples.
-
-
-JAVADOM
-- The DOMViewer example in the Pluglets example list is a JavaDOM example
-
-
-WEBCLIENT
-- set the Environment variable MOZILLA_FIVE_HOME to the location of your 
-  Netscape 6 binaries. If you install the SVR4 package, this will be
-  setenv MOZILLA_FIVE_HOME /opt/SUNWns6
-- cd to the javadev/example directory
-- run the shell script runem as
-  runem <your url>
-
-
-============================================================================
-Copyright 2000 Sun Microsystems, Inc., 901 San Antonio Road, Palo Alto,
-California 94303 U.S.A. All rights reserved.
-
-Sun, Sun Microsystems, Java, SunOS, OpenWindows, and Solaris are trademarks,
-registered trademarks, or service marks of Sun Microsystems, Inc. in the U.S.A.
-and other countries. All SPARC trademarks are used under license and are
-trademarks or registered trademarks of SPARC International, Inc. in the U.S.A.
-and other countries. Products bearing SPARC trademarks are based upon an
-architecture developed by Sun Microsystems, Inc. Netscape is a trademark of
-Netscape Communications Corporation.  PostScript is a trademark of Adobe
-Systems, Incorporated, which may be registered in certain jurisdictions.
-

mozilla/java/changelo

@@ -1,5 +0,0 @@
-Fri Jul 30 14:57:28 1999  Ed Burns  <Ed Burns <ed.burns@sun.com>>
-
-	* Made necessary changes to build files to build with jdk1.1.7 or
- 	jdk1.2.2.
-	

mozilla/java/config/buildpkg.bat

@@ -1,44 +0,0 @@
-@echo off
-rem The contents of this file are subject to the Netscape Public
-rem License Version 1.1 (the "License"); you may not use this file
-rem except in compliance with the License. You may obtain a copy of
-rem the License at http://www.mozilla.org/NPL/
-rem
-rem Software distributed under the License is distributed on an "AS
-rem IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-rem implied. See the License for the specific language governing
-rem rights and limitations under the License.
-rem
-rem The Original Code is mozilla.org code.
-rem
-rem The Initial Developer of the Original Code is Netscape
-rem Communications Corporation.  Portions created by Netscape are
-rem Copyright (C) 1998 Netscape Communications Corporation. All
-rem Rights Reserved.
-rem
-rem Contributor(s): 
-@echo on
-
-@echo off
-if not exist %2 echo Warning: %2 does not exist! (you may need to check it out)
-if not exist %2 exit 1
-
-pushd %2
-
-goto NO_CAFE
-
-if "%MOZ_CAFE%"=="" goto NO_CAFE
-
-mkdir %MOZ_SRC%\mozilla\dist\classes\%2
-%MOZ_TOOLS%\bin\sj.exe -classpath %MOZ_SRC%\mozilla\dist\classes;%MOZ_SRC%\mozilla\sun-java\classsrc -d %MOZ_SRC%\mozilla\dist\classes *.java 
-goto END
-
-:NO_CAFE
-
-perl.exe %MOZ_SRC%\mozilla\config\outofdate.pl -d %MOZ_SRC%\mozilla\dist\classes\%2 -cfg %1 *.java > doit.bat
-call doit.bat
-del /F /A:A doit.bat
-
-:END
-
-popd

mozilla/java/config/localdefs.mak

@@ -1,19 +0,0 @@
-# this file contains defs that should be in the top level mozilla/config
-# directory, but may not be there due to tree update issues.
-
-
-!ifndef JAVA_HOME
-JAVA_HOME=$(JDKHOME)
-!endif
-
-JAVA_DESTPATH = $(MOZ_SRC)\mozilla\dist\classes
-DEFAULT_JAVA_SOURCEPATH = $(MOZ_SRC)\mozilla\sun-java\classsrc
-JAVA_SOURCEPATH = $(MOZ_SRC)\mozilla\sun-java\classsrc11;$(DEFAULT_JAVA_SOURCEPATH)
-JAVAC_ZIP=$(JAVA_HOME)\lib\classes.zip
-JAVAC_CLASSPATH=$(JAVAC_ZIP)$(PATH_SEPARATOR)$(JAVA_DESTPATH)$(PATH_SEPARATOR)$(JAVA_SOURCEPATH)
-
-
-JAVA=$(JDKHOME)\bin\java
-JAVAH=$(JDKHOME)\bin\JAVAH
-JAVAH_FLAGS=-jni -classpath $(JAVAC_CLASSPATH)
-

mozilla/java/config/outofdate.pl

@@ -1,134 +0,0 @@
-#!perl
-#
-# 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): 
-# 
-
-#
-#Input: [-d dir] foo1.java foo2.java
-#Compares with: foo1.class foo2.class (if -d specified, checks in 'dir', 
-#  otherwise assumes .class files in same directory as .java files)
-#Returns: list of input arguments which are newer than corresponding class
-#files (non-existant class files are considered to be real old :-)
-#
-
-$found = 1;
-
-# GLOBALS
-$SEP = 0; # the paltform independent path separator
-$CFG = 0; # the value of the -cfg flag
-
-# determine the path separator
-$_ = $ENV{"PATH"};
-if (m|/|) {
-	$SEP = "/";
-}
-else {
-	$SEP = "\\";
-}
-
-if ($ARGV[0] eq '-d') {
-    $classdir = $ARGV[1];
-    $classdir .= $SEP;
-    shift;
-    shift;
-} else {
-    $classdir = "." . $SEP;
-}
-
-# if -cfg is specified, print out the contents of the cfg file to stdout
-if ($ARGV[0] eq '-cfg') {
-    $CFG = $ARGV[1];
-    shift;
-    shift;
-} 
-
-$_ = $ARGV[0];
-if (m/\*.java/) {
-	# Account for the fact that the shell didn't expand *.java by doing it
-	# manually.
-	&manuallyExpandArgument("java");
-}
-
-$printFile = 0;
-
-foreach $filename (@ARGV) {
-    $classfilename = $classdir;
-    $classfilename .= $filename;
-    $classfilename =~ s/.java$/.class/;
-# workaround to only build sun/io/* classes when necessary
-# change the pathname of target file to be consistent
-# with sun/io subdirectories
-#
-# sun/io was always getting rebuilt because the java files
-# were split into subdirectories, but the package names
-# remained the same.  This was confusing outofdate.pl
-#
-    $classfilename =~ s/sun\/io\/extended.\//sun\/io\//;
-    $classfilename =~ s/\.\.\/\.\.\/sun-java\/classsrc\///;
-    ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,
-     $ctime,$blksize,$blocks) = stat($filename);
-    ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$classmtime,
-     $ctime,$blksize,$blocks) = stat($classfilename);
-#    print $filename, " ", $mtime, ", ", $classfilename, " ", $classmtime, "\n";
-    if ($mtime > $classmtime) {
-
-		# Only print the file header if we actually have some files to
-		# compile.
-		if (!$printFile) {
-			$printFile = 1;
-			&printFile($CFG);
-		}
-        print $filename, " ";
-        $found = 0;
-    }
-}
-
-print "\n";
-
-# push onto $ARG array all filenames with extension $ext
-
-# @param ext the extension of the file
-
-sub manuallyExpandArgument {
-	local($ext) = @_;
-	$ext = "\." . $ext;			# put it in regexp
-
-	$result = opendir(DIR, ".");
-
-	@allfiles = grep(/$ext/, readdir(DIR));
-	$i = 0;
-	foreach $file (@allfiles) {
-		#skip emacs save files
-		$_ = $file;
-		if (!/~/) {
-			$ARGV[$i++] = $file;
-		}
-	}
-}
-
-sub printFile {
-	local($file) = @_;
-
-	$result = open(CFG, $file);
-	while (<CFG>) {
-		chop;
-		print $_;
-	}
-}

mozilla/java/dom/DOMAccessor.java.patch

@@ -1,10 +0,0 @@
-Index: DOMAccessor.java
-===================================================================
-RCS file: /cvsroot/mozilla/java/dom/classes/org/mozilla/dom/DOMAccessor.java,v
-retrieving revision 1.2
-diff -r1.2 DOMAccessor.java
-31a32,33
-> import org.mozilla.dom.util.GenericDocLoadListener;
-> 
-38a41
->         addDocumentLoadListener(new GenericDocLoadListener("JavaDOM"));

mozilla/java/dom/Makefile

@@ -1,30 +0,0 @@
-#!gmake
-# 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	= ../..
-topsrcdir	= ../..
-VPATH		= .
-srcdir		= .
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS = classes jni src
-
-include $(topsrcdir)/config/rules.mk

mozilla/java/dom/Makefile.in

@@ -1,30 +0,0 @@
-#!gmake
-# 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	= ../..
-topsrcdir	= @top_srcdir@
-VPATH		= @srcdir@
-srcdir		= @srcdir@
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS = classes src jni
-
-include $(topsrcdir)/config/rules.mk

mozilla/java/dom/README

@@ -1,153 +0,0 @@
-
-Sources
-=======
-
-The sources are located in mozilla/java/dom.
-Subdirectories 
-
-    classes
-    jni
-    src
-    tests
-
-contain Java sources, Java native methods implementation, 
-native c++ code and Java DOM API tests respectively.
-
-Note: 
-   Sources that work with mozilla PR1 and earlier
-   versions should be checked out using DOM_PR1 tag.
-
-   No tags are needed for the sources that work with
-   the latest mozilla tree.
-
-Building
-========
-
-   Requirenments:
-   --------------
-     Current mozilla build
-     JDK1.2 or JDK1.3 
-     Perl 5 must be in your path
-     JDKHOME environment variable set to your JDK dir
-     CLASSPATH environment cvariable set to contain 
-	org.w3c.dom classes. The sources can be found at	
-        http://www.w3.org/TR/2000/CR-DOM-Level-2-20000307/java-binding.html
-	(for mozilla PR1 and earlie versions)
-        http://www.w3.org/TR/2000/CR-DOM-Level-2-20000510/java-binding.html
-	(for the latest mozilla)
-
-     Solaris specific
-     ----------------
-	Add following directories to LD_LIBRARY_PATH environment variable:
-          $MOZILLA_FIVE_HOME
-          $JDKHOME/jre/lib/$HOSTTYPE/native_threads
-          $JDKHOME/jre/lib/$HOSTTYPE/classic
-          $JDKHOME/jre/lib/$HOSTTYPE/
-
-	goto mozilla/java/dom directory and type "gmake"
-        
-
-     Windows NT specific
-     -------------------
-	To enable OJI usage set environment variable JAVA_DOM_OJI_ENABLE=1
-	Add following directories to PATH environment variable:
-	  %MOZILLA_FIVE_HOME%
-	  %JDKHOME%\jre\bin\classic (only in case you don't use OJI)
-
-	goto mozilla/java/dom directory and type "nmake /f makefile.win"
-        
-
-Using the Java DOM API
-======================
-
-A Java component obtains a org.w3c.dom.Document by registering for
-Document load notifications. The Document is passed in along with the
-notifications. The preferred way for a Java component to register for
-Document load notifications is to register via the DOMAccessor class.
-
-However, this is possible only if OJI usage is enabled. This works
-on Windows NT platform.
-
-On Solaris currently the nsJavaDOM component instantiates its own JVM.
-When an OJI-compatible JVM is available, we will move over to using it.
-So, one has to apply two patches to
-
-  mozilla/webshell/src/nsWebShell.cpp
-  mozilla/java/dom/classes/org/mozilla/dom/DOMAccessor.java
-
-They can be found at mozilla/java/dom directory.
-The first one inits nsJavaDOM component and adds it as a
-document load observer listener.
-
-The second one registers a document load listener via DOMAccessor. 
-Note:
-  any class that implements the DocumentLoadListener interface may
-  stand for GenericDocLoadListener.
-
-After applying a patch to nsWebShell.cpp edit 
-mozilla/webshell/src/Makefile.in to add -DJAVA_DOM to the list of 
-defines. Then do a gmake in this directory.
-
-After applying a patch to DOMAccessor.java go to mozilla/java/dom/classes
-and do a gmake. No changes in makefiles are needed.
-
-You can find examples of Java DOM API usage in 
-
-   mozilla/java/dom/classes/org/mozilla/dom/util
-   mozilla/java/dom/tests/src/applets
-
-
-DOM2 events
-------------
-
-At the moment all DOM2 event-related interfaces are present
-however they are not fully implemented yet
-because Mozilla's core DOM does not support DOM2 events fully. 
-Consequences:
-  - some methods throws OperationUnsupportedException()
-
-The basic implementation architecture is following:
-   - NodeImpl is extended to support EventTarget interface
-   - for every addEventListener call special NativeDOMProxyListener object is 
-       created and is registered with Mozilla's DOM 
-     It's task is to propagate event notifications from Mozilla's DOM
-       to target Java EventListener
-   - In order to sucessfully unregister EventListeners we need to 
-       save association between java EventListener and corresponding 
-       NativeDOMProxyListener object. This is done by storing such
-       associations Vector at NodeImpl
-   - javaDOMEventsGlobals class is used much like javaDOMGlobals for caching
-     (this code may be moved to javaDOMGlobals) 
-     
-NSPR Logging
-------------
-
-The NSPR Log module name is javadom. For instructions on how to enable
-logging, see dist/include/prlog.h
-
-
-Debug output
-------------
-
-The debug build of the Java DOM API creates the JVM with the verbose
-and the verboseGC options turned on, to help in debugging. It also
-creates two files in the current working directory, dom-java.txt and
-dom-cpp.txt, which are simple dumps of the DOM, as printed from C++
-and from Java. The two should be identical. The code to write these
-files is, essentially, my regression test. Feel free to add to it.
-
-
-Dependencies
-------------
-
-Currently tested on Solaris 7 only with Java 2 SDK 1.2.1. egcs-2.91.66, 
-Sun Workshop C++ 4.2 and 5.0 have been know to compile this code
-fine. gcc-2.8.1 does *not* work. I have not used anything
-Java2-specific, and it works with JDK1.1.x too (I have been using JDK
-1.1.6 too).
-
-
-References
-----------
-
-I highly recommend reading Sheng Liang's new JNI book.

mozilla/java/dom/TODO

@@ -1,25 +0,0 @@
-o Convert to using IDL and GenericFactories. Once support for
-  ComponentLoaders is implemented in xpcom, use that to load our
-  component.
-
-  [5d]
-
-o Use OJI to obtain the JVM.
-
-  [5d. Awaiting OJI availability]
-
-o i18n the API
-
-o Use nsISupportsProxies to work around thread 
-  limitations. This will mean writing an IDL for nsIJavaDOM.h, but 
-  that sould be trivial. Dcumentation for nsISupportsProxies is 
-  available at
-  http://www.mozilla.org/projects/xpcom/Proxies.html.
-
-  [2w. Assigned. Contact: Sergey Lunegov <lsv@sparc.spb.su>]
-
-o Investigate the possibility of writing a tool that can generate the
-  JNI code from idl. This is the only practical way to implement the
-  HTML DOM (because it is too big to hand-code).
-
-  [4w+]

mozilla/java/dom/classes/Makefile

@@ -1,42 +0,0 @@
-#!gmake
-# 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	= ../../..
-topsrcdir	= ../../..
-VPATH		= .
-srcdir		= .
-
-IGNORE_MANIFEST=1 
-JAVA_OR_NSJVM=1
-NO_CAFE=1
-
-JDIRS = org/mozilla/dom 	\
-	org/mozilla/dom/events	\
-	org/mozilla/dom/util	\
-	$(NULL)
-
-
-include $(DEPTH)/config/autoconf.mk
-include $(topsrcdir)/config/rules.mk
-
-JAVAC_PROG = $(JDKHOME)/bin/javac
-JAVAC_FLAGS = -classpath $(CLASSPATH):$(JAVA_DESTPATH) -d $(JAVA_DESTPATH)
-JAVAC = $(JAVAC_PROG) $(JAVAC_FLAGS)
-

mozilla/java/dom/classes/Makefile.in

@@ -1,42 +0,0 @@
-#!gmake
-# 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	= ../../..
-topsrcdir	= @top_srcdir@
-VPATH		= @srcdir@
-srcdir		= @srcdir@
-
-IGNORE_MANIFEST=1 
-JAVA_OR_NSJVM=1
-NO_CAFE=1
-
-JDIRS = org/mozilla/dom 	\
-	org/mozilla/dom/events	\
-	org/mozilla/dom/util	\
-	$(NULL)
-
-
-include $(DEPTH)/config/autoconf.mk
-include $(topsrcdir)/config/rules.mk
-
-JAVAC_PROG = $(JDKHOME)/bin/javac
-JAVAC_FLAGS = -classpath $(CLASSPATH) -d $(JAVA_DESTPATH)
-JAVAC = $(JAVAC_PROG) $(JAVAC_FLAGS)
-

mozilla/java/dom/classes/makefile.win

@@ -1,37 +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 Sun Microsystems,
-# Inc. Portions created by Sun are
-# Copyright (C) 1999 Sun Microsystems, Inc. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-IGNORE_MANIFEST=1 
-DEPTH = ..\..\..
-
-JAVA_OR_NSJVM=1
-NO_CAFE=1
-
-include <$(DEPTH)\config\config.mak>
-
-JDIRS = org\mozilla\dom \
-	org\mozilla\dom\events \
-	org\mozilla\dom\util \
-	$(NULL)
-
-JAVAC_PROG=$(JDKHOME)\bin\javac
-JAVAC_FLAGS=-classpath $(CLASSPATH);$(JAVA_DESTPATH) -d $(JAVA_DESTPATH)
-include <$(DEPTH)\config\javarules.mak>
-include <$(DEPTH)\config\rules.mak>

mozilla/java/dom/classes/org/mozilla/dom/AttrImpl.java

@@ -1,43 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Attr;
-import org.w3c.dom.Element;
-
-public class AttrImpl extends NodeImpl implements Attr {
-
-    // instantiated from JNI or Document.createAttribute()
-    private AttrImpl() {}
-
-    public native String getName();
-    public native boolean getSpecified();
-    public native String getValue();
-    public native void setValue(String value);
-
-    /**
-     * The <code>Element</code> node this attribute is attached to or
-     * <code>null</code> if this attribute is not in use.
-     * @since DOM Level 2
-     */
-    public native Element getOwnerElement();
-}

mozilla/java/dom/classes/org/mozilla/dom/CDATASectionImpl.java

@@ -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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.CDATASection;
-
-public class CDATASectionImpl extends TextImpl implements CDATASection {
-
-    // instantiated from JNI or Document.createCDATASection()
-    private CDATASectionImpl() {}
-}
-

mozilla/java/dom/classes/org/mozilla/dom/CharacterDataImpl.java

@@ -1,39 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.CharacterData;
-
-public class CharacterDataImpl extends NodeImpl implements CharacterData {
-
-    // instantiated from JNI only
-    protected CharacterDataImpl() {}
-
-    public native void appendData(String arg);
-    public native void deleteData(int offset, int count);
-    public native String getData();
-    public native int getLength();
-    public native void insertData(int offset, String arg);
-    public native void replaceData(int offset, int count, String arg);
-    public native void setData(String data);
-    public native String substringData(int offset, int count);
-}

mozilla/java/dom/classes/org/mozilla/dom/CommentImpl.java

@@ -1,30 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Comment;
-
-public class CommentImpl extends CharacterDataImpl implements Comment {
-
-    // instantiated from JNI or Document.createComment()
-    private CommentImpl() {}
-}

mozilla/java/dom/classes/org/mozilla/dom/DOMAccessor.java

@@ -1,203 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-/*
-
- * W3C® IPR SOFTWARE NOTICE
-
- * Copyright © 1994-2000 World Wide Web Consortium, (Massachusetts
- * Institute of Technology, Institut National de Recherche en
- * Informatique et en Automatique, Keio University). All Rights
- * Reserved. http://www.w3.org/Consortium/Legal/
-
- * This W3C work (including software, documents, or other related items) is
- * being provided by the copyright holders under the following
- * license. By obtaining, using and/or copying this work, you (the
- * licensee) agree that you have read, understood, and will comply with
- * the following terms and conditions:
-
- * Permission to use, copy, and modify this software and its documentation,
- * with or without modification, for any purpose and without fee or
- * royalty is hereby granted, provided that you include the following on
- * ALL copies of the software and documentation or portions thereof,
- * including modifications, that you make:
-
- * The full text of this NOTICE in a location viewable to users of the
- * redistributed or derivative work.
-
- * Any pre-existing intellectual property disclaimers, notices, or terms
- * and conditions. If none exist, a short notice of the following form
- * (hypertext is preferred, text is permitted) should be used within the
- * body of any redistributed or derivative code: "Copyright ©
- * [$date-of-software] World Wide Web Consortium, (Massachusetts
- * Institute of Technology, Institut National de Recherche en
- * Informatique et en Automatique, Keio University). All Rights
- * Reserved. http://www.w3.org/Consortium/Legal/"
-
- * Notice of any changes or modifications to the W3C files, including
- * the date changes were made. (We recommend you provide URIs to the
- * location from which the code is derived.)
-
- * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS," AND COPYRIGHT
- * HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED,
- * INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR
- * FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR
- * DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS,
- * TRADEMARKS OR OTHER RIGHTS.
-
- * COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT,
- * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE
- * SOFTWARE OR DOCUMENTATION.
-
- * The name and trademarks of copyright holders may NOT be used in
- * advertising or publicity pertaining to the software without specific,
- * written prior permission. Title to copyright in this software and any
- * associated documentation will at all times remain with copyright
- * holders.
-
- */
-
-
-package org.mozilla.dom;
-
-import java.util.Vector;
-import java.util.Enumeration;
-
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
-
-import java.security.AccessController;
-
-public final class DOMAccessor {
-
-    private static Vector documentLoadListeners = new Vector();
-    private static JavaDOMPermission permission = new JavaDOMPermission("JavaDOM");
-
-    static {
-	System.loadLibrary("javadomjni");
-    }
-
-    private void DOMAccessorImpl() {}
-
-    private static native void register();
-    private static native void unregister();
-    private static native Node getNodeByHandle(long p);
-    private static native void doGC();
-
-    public static native void initialize();
-
-    public static synchronized void 
-	addDocumentLoadListener(DocumentLoadListener listener) {
-	if (documentLoadListeners.size() == 0) {
-	    register();
-	}
-	documentLoadListeners.addElement(listener);
-    }
-
-    public static synchronized void 
-	removeDocumentLoadListener(DocumentLoadListener listener) {
-
-	documentLoadListeners.removeElement(listener);
-	if (documentLoadListeners.size() == 0) {
-	  unregister();
-	}
-    }
-
-    public static synchronized void 
-        startURLLoad(String url, String contentType, long p_doc) {
-
-	AccessController.checkPermission(permission);
-	for (Enumeration e = documentLoadListeners.elements();
-	     e.hasMoreElements();) {
-	    DocumentLoadListener listener = 
-		(DocumentLoadListener) e.nextElement();
-	    listener.startURLLoad(url, contentType, (Document)getNodeByHandle(p_doc));
-	}
-	doGC();
-    }
-
-    public static synchronized void 
-	endURLLoad(String url, int status, long p_doc) {
-
-	AccessController.checkPermission(permission);
-	for (Enumeration e = documentLoadListeners.elements();
-	     e.hasMoreElements();) {
-	    DocumentLoadListener listener = 
-		(DocumentLoadListener) e.nextElement();
-	    listener.endURLLoad(url, status, (Document)getNodeByHandle(p_doc));
-	}
-	doGC();
-    }
-
-    public static synchronized void 
-	progressURLLoad(String url, int progress, int progressMax, 
-			long p_doc) {
-
-	AccessController.checkPermission(permission);
-	for (Enumeration e = documentLoadListeners.elements();
-	     e.hasMoreElements();) {
-	    DocumentLoadListener listener = 
-		(DocumentLoadListener) e.nextElement();
-	    listener.progressURLLoad(url, progress, progressMax, (Document)getNodeByHandle(p_doc));
-	}
-	doGC();
-    }
-
-    public static synchronized void 
-        statusURLLoad(String url, String message, long p_doc) {
-
-	AccessController.checkPermission(permission);
-	for (Enumeration e = documentLoadListeners.elements();
-	     e.hasMoreElements();) {
-	    DocumentLoadListener listener = 
-		(DocumentLoadListener) e.nextElement();
-	    listener.statusURLLoad(url, message, (Document)getNodeByHandle(p_doc));
-	}
-	doGC();
-    }
-
-
-    public static synchronized void 
-        startDocumentLoad(String url) {
-
-	AccessController.checkPermission(permission);
-	for (Enumeration e = documentLoadListeners.elements();
-	     e.hasMoreElements();) {
-	    DocumentLoadListener listener = 
-		(DocumentLoadListener) e.nextElement();
-	    listener.startDocumentLoad(url);
-	}
-	doGC();
-    }
-
-    public static synchronized void 
-        endDocumentLoad(String url, int status, long p_doc) {
-
-	AccessController.checkPermission(permission);
-	for (Enumeration e = documentLoadListeners.elements();
-	     e.hasMoreElements();) {
-	    DocumentLoadListener listener = 
-		(DocumentLoadListener) e.nextElement();
-	    listener.endDocumentLoad(url, status, (Document)getNodeByHandle(p_doc));
-	}
-	doGC();
-    }
-}

mozilla/java/dom/classes/org/mozilla/dom/DOMExceptionImpl.java

@@ -1,32 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.DOMException;
-
-public class DOMExceptionImpl extends DOMException
-{
-    // instantiated from JNI only
-    private DOMExceptionImpl(short code, String message) { 
-	super(code, message); 
-    }
-}

mozilla/java/dom/classes/org/mozilla/dom/DOMImplementationImpl.java

@@ -1,62 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.DOMImplementation;
-import org.w3c.dom.Document;
-import org.w3c.dom.DocumentType;
-import org.w3c.dom.DOMException;
-
-public class DOMImplementationImpl implements DOMImplementation {
-
-    private long p_nsIDOMDOMImplementation = 0;
-
-    // instantiated from JNI only
-    private DOMImplementationImpl() {}
-
-    public boolean equals(Object o) {
-	if (!(o instanceof NodeListImpl))
-	    return false;
-	else
-	    return (XPCOM_equals(o));
-    }
-
-    public int hashCode(){
-	return XPCOM_hashCode();
-    }
-
-    public native boolean hasFeature(String feature, String version);
-
-    protected native void finalize();
-
-    private native boolean XPCOM_equals(Object o);
-    private native int XPCOM_hashCode();
-
-    //since DOM2
-    public native DocumentType createDocumentType(String qualifiedName, 
-						  String publicID, 
-						  String systemID);
-
-    public native Document createDocument(String namespaceURI,
-					  String qualifiedName,
-					  DocumentType doctype);
-}

mozilla/java/dom/classes/org/mozilla/dom/DocumentFragmentImpl.java

@@ -1,29 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.DocumentFragment;
-
-public class DocumentFragmentImpl extends NodeImpl implements DocumentFragment {
-    // instantiated from JNI or Document.createDocumentFragment()
-    private DocumentFragmentImpl() {}
-}

mozilla/java/dom/classes/org/mozilla/dom/DocumentImpl.java

@@ -1,78 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Attr;
-import org.w3c.dom.CDATASection;
-import org.w3c.dom.Comment;
-import org.w3c.dom.Document;
-import org.w3c.dom.DocumentFragment;
-import org.w3c.dom.Element;
-import org.w3c.dom.EntityReference;
-import org.w3c.dom.ProcessingInstruction;
-import org.w3c.dom.Text;
-import org.w3c.dom.DocumentType;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-import org.w3c.dom.DOMImplementation;
-import org.w3c.dom.events.DocumentEvent;
-import org.w3c.dom.events.Event;
-import org.w3c.dom.DOMException;
-
-public class DocumentImpl extends NodeImpl implements Document, DocumentEvent {
-
-    // instantiated from JNI only
-    private DocumentImpl() {}
-
-    public native Attr createAttribute(String name);
-    public native CDATASection createCDATASection(String data);
-    public native Comment createComment(String data);
-    public native DocumentFragment createDocumentFragment();
-    public native Element createElement(String tagName);
-    public native EntityReference createEntityReference(String name);
-    public native ProcessingInstruction 
-	createProcessingInstruction(String target, 
-				    String data);
-    public native Text createTextNode(String data);
-
-    public native DocumentType getDoctype();
-    public native Element getDocumentElement();
-    public native NodeList getElementsByTagName(String tagName);
-    public native DOMImplementation getImplementation();
-    public native Event createEvent(String type);
-    public native NodeList getElementsByTagNameNS(String namespaceURI, String localName);
-    public native Element getElementById(String elementId);
-
-    public Node importNode(Node importedNode, boolean deep) throws DOMException {
-        throw new UnsupportedOperationException();
-    }
-
-    public Element createElementNS(String namespaceURI, String qualifiedName)
-                                            throws DOMException {
-        throw new UnsupportedOperationException();
-    } 
-
-    public Attr createAttributeNS(String namespaceURI, String qualifiedName)
-                                              throws DOMException {
-        throw new UnsupportedOperationException();
-    } 
-}

mozilla/java/dom/classes/org/mozilla/dom/DocumentLoadListener.java

@@ -1,36 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Document;
-
-public interface DocumentLoadListener {
-
-    public void startURLLoad(String url, String contentType, Document doc);
-    public void endURLLoad(String url, int status, Document doc);
-    public void progressURLLoad(String url, int progress, int progressMax, 
-				Document doc);
-    public void statusURLLoad(String url, String message, Document doc);
-
-    public void startDocumentLoad(String url);
-    public void endDocumentLoad(String url, int status, Document doc);
-}

mozilla/java/dom/classes/org/mozilla/dom/DocumentTypeImpl.java

@@ -1,40 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.DocumentType;
-import org.w3c.dom.NamedNodeMap;
-
-public class DocumentTypeImpl  extends NodeImpl implements DocumentType {
-
-    // instantiated from JNI only
-    private DocumentTypeImpl() {}
-
-    public native String getName();
-    public native NamedNodeMap getEntities();
-    public native NamedNodeMap getNotations();
-    
-    //since DOM level 2
-    public native String getPublicId();
-    public native String getSystemId();
-    public native String getInternalSubset();
-}

mozilla/java/dom/classes/org/mozilla/dom/ElementImpl.java

@@ -1,53 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Attr;
-import org.w3c.dom.Element;
-import org.w3c.dom.NodeList;
-import org.w3c.dom.DOMException;
-
-public class ElementImpl extends NodeImpl implements Element {
-
-    // instantiated from JNI or Document.createElement()
-    private ElementImpl() {}
-
-    public native String getAttribute(String name);
-    public native Attr getAttributeNode(String name);
-    public native NodeList getElementsByTagName(String name);
-    public native String getTagName();
-    public native void normalize();
-    public native void removeAttribute(String name);
-    public native Attr removeAttributeNode(Attr oldAttr);
-    public native void setAttribute(String name, String value);
-    public native Attr setAttributeNode(Attr newAttr);
-
-    //since DOM2
-    public native String getAttributeNS(String namespaceURI, String localName);
-    public native void setAttributeNS(String namespaceURI, String qualifiedName, String value);
-    public native void removeAttributeNS(String namespacURI, String localName);   
-    public native Attr getAttributeNodeNS(String namespaceURI, String localName);
-    public native Attr setAttributeNodeNS(Attr newAttr);
-    public native NodeList getElementsByTagNameNS(String namespaceURI, String localName);
-    public native boolean hasAttribute(String name);
-    public native boolean hasAttributeNS(String namespaceURI, String localName);
-}

mozilla/java/dom/classes/org/mozilla/dom/EntityImpl.java

@@ -1,34 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Entity;
-
-public class EntityImpl extends NodeImpl implements Entity {
-
-    // instantiated from JNI only
-    private EntityImpl() {}
-    
-    public native String getPublicId();
-    public native String getSystemId();
-    public native String getNotationName();
-}

mozilla/java/dom/classes/org/mozilla/dom/EntityReferenceImpl.java

@@ -1,30 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.EntityReference;
-
-public class EntityReferenceImpl extends NodeImpl implements EntityReference {
-
-    // instantiated from JNI or Document.createEntityReference()
-    private EntityReferenceImpl() {}
-}

mozilla/java/dom/classes/org/mozilla/dom/JavaDOMPermission.java

@@ -1,36 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import java.security.BasicPermission;
-
-public final class JavaDOMPermission extends BasicPermission {
-    public JavaDOMPermission(String name)
-    {
-	super(name);
-    }
-
-    public JavaDOMPermission(String name, String actions)
-    {
-	super(name);
-    }
-}

mozilla/java/dom/classes/org/mozilla/dom/NamedNodeMapImpl.java

@@ -1,54 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.Node;
-import org.w3c.dom.DOMException;
-
-public class NamedNodeMapImpl implements NamedNodeMap {
-
-    private long p_nsIDOMNamedNodeMap = 0;
-    // instantiated from JNI only
-    private NamedNodeMapImpl() {}
-
-    public native int getLength();
-    public native Node getNamedItem(String name);
-    public native Node item(int index);
-    public native Node removeNamedItem(String name);
-    public native Node setNamedItem(Node arg);
-
-    
-    public Node getNamedItemNS(String namespaceURI, String localName) {
-        throw new UnsupportedOperationException();
-    }
-
-    public Node removeNamedItemNS(String namespaceURI, String name)
-                                  throws DOMException {
-        throw new UnsupportedOperationException();
-    }    
-
-    public Node         setNamedItemNS(Node arg)
-	                               throws DOMException {
-        throw new UnsupportedOperationException();
-    }
-}

mozilla/java/dom/classes/org/mozilla/dom/NodeImpl.java

@@ -1,219 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.NodeList;
-import org.w3c.dom.Document;
-import org.w3c.dom.DOMException;
-import org.w3c.dom.events.Event;
-import org.w3c.dom.events.EventTarget;
-import org.w3c.dom.events.EventListener;
-import java.util.Vector;
-import java.util.Hashtable;
-
-class NodeEventListener {
-	EventListener listener = null;
-	String type = null;
-	boolean useCapture = false;
-	long nativeListener = 0;
-
-	NodeEventListener(String aType, EventListener aListener, 
-                          boolean aUseCapture, long aNativeListener) {
-		type = aType;
-		listener = aListener;
-		useCapture = aUseCapture;
-		nativeListener = aNativeListener;
-	}
-
-	public boolean equals(Object o) {
-		if (!(o instanceof NodeEventListener))
-			return false;
-		else { 
-			NodeEventListener n = (NodeEventListener) o;
-			if ((useCapture != n.useCapture)  
-                            || (type == null) || !type.equals(n.type) 
-			    || (listener == null) || !listener.equals(n.listener)) 
-				return false;
-			else 
-				return true;
-		}
-	}
-}
-
-public class NodeImpl implements Node, EventTarget {
-
-    /* The derived classes (Attr, CharacterData, DocumentFragment,
-       Document, Element, EntityReference, NamedNodeMap,
-       ProcessingInstruction) will also use this native pointer, since
-       the nsIDOM coreDom classes follow the same hierarchy */
-
-    private long p_nsIDOMNode = 0;
-
-    // this map stores association of java DOM listeners 
-    // with corresponding native Nodes
-    static private Hashtable javaDOMlisteners = new Hashtable();
-
-    // instantiated from JNI only
-    protected NodeImpl() {}
-    protected NodeImpl(long p) {
-	p_nsIDOMNode = p;
-    }
-
-    public boolean equals(Object o) {
-	if (!(o instanceof NodeImpl))
-	    return false;
-	else
-	    return (XPCOM_equals(o));
-	}
-
-    public int hashCode(){
-	return XPCOM_hashCode();
-    }
-
-    public String toString() {
-	return "<" + getNodeName() + 
-	    " t=" + nodeTypeString(getNodeType()) + 
-	    " c=org.mozilla.dom.NodeImpl p=" + 
-	    Long.toHexString(p_nsIDOMNode) + ">";
-    }
-
-    private static String nodeTypeString(int type) {
-	switch (type) {
-	case Node.ELEMENT_NODE: return "ELEMENT";
-	case Node.ATTRIBUTE_NODE: return "ATTRIBUTE";
-	case Node.TEXT_NODE: return "TEXT";
-	case Node.CDATA_SECTION_NODE: return "CDATA_SECTION";
-	case Node.ENTITY_REFERENCE_NODE: return "ENTITY_REFERENCE";
-	case Node.ENTITY_NODE: return "ENTITY";
-	case Node.PROCESSING_INSTRUCTION_NODE: return "PROCESSING_INSTRUCTION";
-	case Node.COMMENT_NODE: return "COMMENT";
-	case Node.DOCUMENT_NODE: return "DOCUMENT";
-	case Node.DOCUMENT_TYPE_NODE: return "DOCUMENT_TYPE";
-	case Node.DOCUMENT_FRAGMENT_NODE: return "DOCUMENT_FRAGMENT";
-	case Node.NOTATION_NODE: return "NOTATION";
-	}
-	return "ERROR";
-    }
-
-    public native Node appendChild(Node newChild) throws DOMException;
-    public native Node cloneNode(boolean deep);
-    public native NamedNodeMap getAttributes();
-    public native NodeList getChildNodes();
-    public native Node getFirstChild();
-    public native Node getLastChild();
-    public native Node getNextSibling();
-    public native String getNodeName();
-    public native short getNodeType();
-    public native String getNodeValue();
-    public native Document getOwnerDocument();
-    public native Node getParentNode();
-    public native Node getPreviousSibling();
-    public native boolean hasChildNodes();
-    public native Node insertBefore(Node newChild, Node refChild) throws DOMException;
-    public native Node removeChild(Node oldChild) throws DOMException;
-    public native Node replaceChild(Node newChild, Node oldChild) throws DOMException;
-    public native void setNodeValue(String nodeValue);
-
-    protected native void finalize();
-
-    private native boolean XPCOM_equals(Object o);
-    private native int XPCOM_hashCode();
-
-    //since DOM level 2
-    public native boolean supports(String feature, String version);
-    public native String getNamespaceURI();
-    public native String getPrefix();
-    public native void setPrefix(String prefix);
-    public native String getLocalName();
-    
-    public void addEventListener(String type, 
-                                 EventListener listener, 
-                                 boolean useCapture) {
-
-        long nativeListener = addNativeEventListener(type, listener, useCapture);
-
-	Long lnode = new Long(p_nsIDOMNode);
-
-        Vector listeners;
-        
-        //in conjunction with internal synchronization of Hashtable and Vector
-        // this should be enough for safe concurrent access
-        synchronized (javaDOMlisteners) {
-            listeners = (Vector) javaDOMlisteners.get(lnode);
-        
-            if (listeners == null) {
-              listeners = new Vector();
-                javaDOMlisteners.put(lnode, listeners);
-            }
-        }
-        
-        if (nativeListener != 0) {
-
-            NodeEventListener l = new NodeEventListener(type, 
-                                                        listener, 
-                                                        useCapture, 
-                                                        nativeListener);
-            listeners.add(l);
-	} 
-    }
-
-    public void removeEventListener(String type, 
-                                    EventListener listener, 
-                                    boolean useCapture) {
-
-        Vector listeners = (Vector) javaDOMlisteners.get(new Long(p_nsIDOMNode));
-
-        if (listeners == null) 
-            return;
-
-        NodeEventListener l = new NodeEventListener(type, 
-                                                    listener, useCapture, 0);
-
-        int idx = listeners.indexOf(l);
-
-	//if trying to remove non-existing listener then return 
-        if (idx == -1) 
-            return;
-
-    	l = (NodeEventListener) listeners.remove(idx);
-	
-	    removeNativeEventListener(type, l.nativeListener, useCapture);
-    }
-
-    public boolean dispatchEvent(Event evt) throws DOMException {
-        throw new UnsupportedOperationException();
-    }
-    
-    private native long  addNativeEventListener(String type,
-                                             EventListener listener,
-                                             boolean useCapture);
-
-    private native void  removeNativeEventListener(String type,
-                                                long nativeListener,
-                                                boolean useCapture);
-
-    public void         normalize() {
-        throw new UnsupportedOperationException();
-    };
-}

mozilla/java/dom/classes/org/mozilla/dom/NodeListImpl.java

@@ -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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
-public class NodeListImpl implements NodeList {
-
-    private long p_nsIDOMNodeList = 0;
-
-    // instantiated from JNI or Document.createAttribute()
-    private NodeListImpl() {}
-
-    public boolean equals(Object o) {
-	if (!(o instanceof NodeListImpl))
-	    return false;
-	else
-	    return (XPCOM_equals(o));
-    }
-
-    public int hashCode(){
-	return XPCOM_hashCode();
-    }
-
-    public native int getLength();
-    public native Node item(int index);
-
-    protected native void finalize();
-
-    private native boolean XPCOM_equals(Object o);
-    private native int XPCOM_hashCode();
-}

mozilla/java/dom/classes/org/mozilla/dom/NotationImpl.java

@@ -1,33 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Notation;
-
-public class NotationImpl extends NodeImpl implements Notation {
-
-    // instantiated from JNI only
-    private NotationImpl() {}
-    
-    public native String getPublicId();
-    public native String getSystemId();
-}

mozilla/java/dom/classes/org/mozilla/dom/ProcessingInstructionImpl.java

@@ -1,34 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.ProcessingInstruction;
-
-public class ProcessingInstructionImpl extends NodeImpl implements ProcessingInstruction {
-
-    // instantiated from JNI or Document.createProcessingInstruction()
-    private ProcessingInstructionImpl() {}
-
-    public native String getData();
-    public native String getTarget();
-    public native void setData(String data);
-}

mozilla/java/dom/classes/org/mozilla/dom/TextImpl.java

@@ -1,33 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom;
-
-import org.w3c.dom.Text;
-
-public class TextImpl extends CharacterDataImpl implements Text {
-
-    // instantiated from JNI or Document.createTextNode()
-    protected TextImpl() {}
-
-    public native Text splitText(int offset);
-}    
-

mozilla/java/dom/classes/org/mozilla/dom/events/EventImpl.java

@@ -1,151 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom.events;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.events.Event;
-import org.w3c.dom.events.EventTarget;
-
-/**
- * The <code>Event</code> interface is used to provide contextual information 
- * about an event to the handler processing the event.  An object which 
- * implements the <code>Event</code> interface is generally passed as the 
- * first parameter to an event handler.  More specific  context information 
- * is passed to event handlers by deriving additional interfaces from  
- * <code>Event</code> which contain information directly relating to the type 
- * of event they accompany.  These derived interfaces are also implemented by 
- * the object passed to the event listener. 
- * @since DOM Level 2
- */
-public class EventImpl implements Event {
-
-    protected long p_nsIDOMEvent = 0;
-
-    // instantiated from JNI only
-    protected EventImpl() {}
-
-    public String toString() {
-	return "<c=org.mozilla.dom.events.Event type=" + getType() + 
-	    " target=" + getTarget() +
-            " phase=" + getEventPhase() +
-            " p=" + Long.toHexString(p_nsIDOMEvent) + ">";
-    }
-
-    /**
-     * The <code>type</code> property represents the event name as a string 
-     * property. 
-     */
-    public native String getType();
-    
-    /**
-     * The <code>target</code> property indicates the <code>EventTarget</code> 
-     * to which the event  was originally dispatched. 
-     */
-    public native EventTarget getTarget();
-
-    /**
-     * The <code>currentNode</code> property indicates the <code>Node</code> 
-     * whose <code>EventListener</code>s are currently being processed.  This 
-     * is particularly  useful during capturing and bubbling. 
-     */
-    public native EventTarget getCurrentTarget();
-
-    /**
-     * The <code>eventPhase</code> property indicates which phase of event flow 
-     * is currently  being evaluated. 
-     */
-    public native short getEventPhase();
-    
-    /**
-     * The <code>bubbles</code> property indicates whether or not an event is a 
-     * bubbling event.  If the event can bubble the value is true, else the 
-     * value is false. 
-     */
-    public native boolean getBubbles();
-
-    /**
-     * The <code>cancelable</code> property indicates whether or not an event 
-     * can have its default action prevented.  If the default action can be 
-     * prevented the value is true, else the value is false. 
-     */
-    public native boolean getCancelable();
-
-    /**
-     * The <code>preventBubble</code> method is used to end the bubbling phase 
-     * of  event flow. If this method is called by any 
-     * <code>EventListener</code>s registered on the same 
-     * <code>EventTarget</code> during bubbling, the bubbling phase will cease 
-     * at that level and the event will not be propagated upward within the 
-     * tree. 
-     */
-    public native void preventBubble();
-    
-    /**
-     * The <code>preventCapture</code> method is used to end the capturing phase 
-     * of  event flow. If this method is called by any 
-     * <code>EventListener</code>s registered on the same 
-     * <code>EventTarget</code> during capturing, the capturing phase will 
-     * cease at that level and the event will not be propagated any further 
-     * down. 
-     */
-    public native void preventCapture();
-
-    /**
-     * If an event is cancelable, the <code>preventCapture</code> method is used 
-     * to signify that the event is to be canceled, meaning any default action 
-     * normally taken by the implementation as a result of the event will not 
-     * occur.  If, during any stage of event flow, the 
-     * <code>preventDefault</code> method is called the event is canceled. Any 
-     * default action associated with the event will not occur.  Calling this 
-     * method for a non-cancelable event has no effect.  Once 
-     * <code>preventDefault</code> has been called it will remain in effect 
-     * throughout the remainder of the event's propagation. 
-     */
-    public native void preventDefault();
-    
-    /**
-     * The <code>stopPropagation</code> method is used prevent further 
-     * propagation of an event during event flow. If this method is called by 
-     * any <code>EventListener</code> the event will cease propagating 
-     * through the tree.  The event will complete dispatch to all listeners 
-     * on the current <code>EventTarget</code> before event flow stops.  This 
-     * method may be used during any stage of event flow.
-     */
-    public native void stopPropagation();
-    
-    /**
-     * 
-     * @param eventTypeArg Specifies the event type.  This type may be any event 
-     *   type currently defined in this specification or a new event type.  Any 
-     *   new event type must not begin with any upper, lower, or mixed case 
-     *   version of the string  "DOM".  This prefix is reserved for future DOM 
-     *   event sets.
-     * @param canBubbleArg Specifies whether or not the event can bubble.
-     * @param cancelableArg Specifies whether or not the event's default  action 
-     *   can be prevented.
-     */
-    public native void initEvent(String eventTypeArg, 
-				 boolean canBubbleArg, 
-				 boolean cancelableArg);
-    
-    public native long getTimeStamp();
-}

mozilla/java/dom/classes/org/mozilla/dom/events/MouseEventImpl.java

@@ -1,160 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom.events;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.views.AbstractView;
-import org.w3c.dom.events.MouseEvent;
-import org.w3c.dom.events.EventTarget;
-
-/**
- * The <code>MouseEvent</code> interface provides specific contextual  
- * information associated with Mouse events.
- * <p>The <code>detail</code> attribute inherited from <code>UIEvent</code> 
- * indicates the number of times a mouse button has been pressed and released 
- * over the same screen location during a user action.  The attribute value 
- * is 1 when the user begins this action and increments by 1 for each full 
- * sequence of pressing and releasing. If the user moves the mouse between 
- * the mousedown and mouseup the value will be set to 0, indicating that no 
- * click is occurring.
- * @since DOM Level 2
- */
-public class MouseEventImpl extends UIEventImpl implements MouseEvent {
-
-    // instantiated from JNI only
-    private MouseEventImpl() {}
-
-    public String toString() {
-	return "<c=org.mozilla.dom.events.mouseUIEvent type=" + getType() + 
-            " screen=(" + getScreenX() + "," + getScreenY() + ")" +
-            " client=(" + getClientX() + "," + getClientY() + ")" +
-            " mods=(" + getCtrlKey() + "," + getMetaKey() + "," + getShiftKey() + "," + getAltKey() + ")" +
-            " button=" + getButton() + 
-	    " target=" + getTarget() +
-            " phase=" + getEventPhase() +
-            " p=" + Long.toHexString(p_nsIDOMEvent) + ">";
-    }
-
-    /**
-     * <code>screenX</code> indicates the horizontal coordinate at which the 
-     * event occurred in relative to the origin of the screen coordinate system.
-     */
-    public native int getScreenX();
-    
-    /**
-     * <code>screenY</code> indicates the vertical coordinate at which the event 
-     * occurred relative to the origin of the screen coordinate system.
-     */
-    public native int getScreenY();
-    
-    /**
-     * <code>clientX</code> indicates the horizontal coordinate at which the 
-     * event occurred relative to the DOM implementation's client area.
-     */
-    public native int getClientX();
-    
-    /**
-     * <code>clientY</code> indicates the vertical coordinate at which the event 
-     * occurred relative to the DOM implementation's client area.
-     */
-    public native int getClientY();
-    
-    /**
-     * <code>ctrlKey</code> indicates whether the 'ctrl' key was depressed 
-     * during the firing of the event.
-     */
-    public native boolean getCtrlKey();
-    
-    /**
-     * <code>shiftKey</code> indicates whether the 'shift' key was depressed 
-     * during the firing of the event.
-     */
-    public native boolean getShiftKey();
-    
-    /**
-     * <code>altKey</code> indicates whether the 'alt' key was depressed during 
-     * the firing of the event.  On some platforms this key may map to an 
-     * alternative key name.
-     */
-    public native boolean getAltKey();
-    
-    /**
-     * <code>metaKey</code> indicates whether the 'meta' key was depressed 
-     * during the firing of the event.  On some platforms this key may map to 
-     * an alternative key name.
-     */
-    public native boolean getMetaKey();
-    
-    /**
-     * During mouse events caused by the depression or release of a mouse 
-     * button, <code>button</code> is used to indicate which mouse button 
-     * changed state.
-     */
-    public native short getButton();
-    
-    /**
-     * <code>relatedNode</code> is used to identify a secondary node related to 
-     * a UI event.
-     */
-    public native EventTarget getRelatedTarget();
-    
-    /**
-     * 
-     * @param typeArg Specifies the event type.
-     * @param canBubbleArg Specifies whether or not the event can bubble.
-     * @param cancelableArg Specifies whether or not the event's default  action 
-     *   can be prevent.
-     * @param viewArg Specifies the <code>Event</code>'s 
-     *   <code>AbstractView</code>.
-     * @param detailArg Specifies the <code>Event</code>'s mouse click count.
-     * @param screenXArg Specifies the <code>Event</code>'s screen x coordinate
-     * @param screenYArg Specifies the <code>Event</code>'s screen y coordinate
-     * @param clientXArg Specifies the <code>Event</code>'s client x coordinate
-     * @param clientYArg Specifies the <code>Event</code>'s client y coordinate
-     * @param ctrlKeyArg Specifies whether or not control key was depressed 
-     *   during the <code>Event</code>.
-     * @param altKeyArg Specifies whether or not alt key was depressed during 
-     *   the  <code>Event</code>.
-     * @param shiftKeyArg Specifies whether or not shift key was depressed 
-     *   during the <code>Event</code>.
-     * @param metaKeyArg Specifies whether or not meta key was depressed during 
-     *   the  <code>Event</code>.
-     * @param buttonArg Specifies the <code>Event</code>'s mouse button.
-     * @param relatedNodeArg Specifies the <code>Event</code>'s related Node.
-     */
-    public native void initMouseEvent(String typeArg, 
-				      boolean canBubbleArg, 
-				      boolean cancelableArg, 
-				      AbstractView viewArg, 
-				      int detailArg, 
-				      int screenXArg, 
-				      int screenYArg, 
-				      int clientXArg, 
-				      int clientYArg, 
-				      boolean ctrlKeyArg, 
-				      boolean altKeyArg, 
-				      boolean shiftKeyArg, 
-				      boolean metaKeyArg, 
-				      short buttonArg, 
-				      EventTarget relatedTargetArg);
-}
-

mozilla/java/dom/classes/org/mozilla/dom/events/MutationEventImpl.java

@@ -1,89 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom.events;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.events.MutationEvent;
-import org.mozilla.dom.events.EventImpl;
-
-public class MutationEventImpl extends EventImpl implements MutationEvent  {
-  /**
-   *  <code>relatedNode</code> is used to identify a secondary node related to 
-   * a mutation event. For example, if a mutation event is dispatched to a 
-   * node indicating that its parent has changed, the <code>relatedNode</code>
-   *  is the changed parent.  If an event is instead dispatch to a subtree 
-   * indicating a node was changed within it, the <code>relatedNode</code> is 
-   * the changed node. 
-   */
-  public Node               getRelatedNode() {
-    throw new UnsupportedOperationException();
-  }
-  
-  /**
-   *  <code>prevValue</code> indicates the previous value of text nodes and 
-   * attributes in attrModified and charDataModified events. 
-   */
-  public String             getPrevValue() {
-    throw new UnsupportedOperationException();
-  }
-  
-  /**
-   *  <code>newValue</code> indicates the new value of text nodes and 
-   * attributes in attrModified and charDataModified events. 
-   */
-  public String             getNewValue() {
-    throw new UnsupportedOperationException();
-  }
-  
-  /**
-   *  <code>attrName</code> indicates the changed attr in the attrModified 
-   * event. 
-   */
-  public String             getAttrName() {
-    throw new UnsupportedOperationException();
-  }
-  
-  /**
-   * 
-   * @param typeArg Specifies the event type.
-   * @param canBubbleArg Specifies whether or not the event can bubble.
-   * @param cancelableArg Specifies whether or not the event's default  action 
-   *   can be prevent.
-   * @param relatedNodeArg Specifies the <code>Event</code>'s related Node
-   * @param prevValueArg Specifies the <code>Event</code>'s 
-   *   <code>prevValue</code> property
-   * @param newValueArg Specifies the <code>Event</code>'s 
-   *   <code>newValue</code> property
-   * @param attrNameArg Specifies the <code>Event</code>'s 
-   *   <code>attrName</code> property
-   */
-  public void               initMutationEvent(String typeArg, 
-                                              boolean canBubbleArg, 
-                                              boolean cancelableArg, 
-                                              Node relatedNodeArg, 
-                                              String prevValueArg, 
-                                              String newValueArg, 
-                                              String attrNameArg) {
-    throw new UnsupportedOperationException();
-  }
-}
-

mozilla/java/dom/classes/org/mozilla/dom/events/UIEventImpl.java

@@ -1,74 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom.events;
-
-import org.w3c.dom.events.UIEvent;
-import org.w3c.dom.views.AbstractView;
-import org.mozilla.dom.events.EventImpl;
-
-/**
- * The <code>UIEvent</code> interface provides specific contextual  
- * information associated with User Interface events.
- * @since DOM Level 2
- */
-public class UIEventImpl extends EventImpl implements UIEvent {
-
-    // instantiated from JNI only
-    protected UIEventImpl() {}
-
-    public String toString() {
-        return "<c=org.mozilla.dom.events.UIEvent type=" + getType() + 
-	        " target=" + getTarget() +
-            " phase=" + getEventPhase() +
-            " p=" + Long.toHexString(p_nsIDOMEvent) + ">";
-    }
-
-
-  /**
-   * The <code>view</code> attribute identifies the <code>AbstractView</code> 
-   * from which the event was generated.
-   */
-  public native AbstractView getView();
-
-  /**
-   * Specifies some detail information about the <code>Event</code>, depending 
-   * on the type of event.
-   */
-  public native int getDetail();
-
-  /**
-   * 
-   * @param typeArg Specifies the event type.
-   * @param canBubbleArg Specifies whether or not the event can bubble.
-   * @param cancelableArg Specifies whether or not the event's default  action 
-   *   can be prevent.
-   * @param viewArg Specifies the <code>Event</code>'s 
-   *   <code>AbstractView</code>.
-   * @param detailArg Specifies the <code>Event</code>'s detail.
-   */
-  public native void initUIEvent(String typeArg, 
-				 boolean canBubbleArg, 
-				 boolean cancelableArg, 
-				 AbstractView viewArg, 
-				 int detailArg);
-}
-

mozilla/java/dom/classes/org/mozilla/dom/util/DOMTreeDumper.java

@@ -1,231 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/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 Initial Developer of the Original Code is Sun Microsystems,
- * Inc. Portions created by Sun are Copyright (C) 1999 Sun Microsystems,
- * Inc. All Rights Reserved. 
- *
- * Contributor(s): Denis Sharypov <sdv@sparc.spb.su>
- *
- */
-
-package org.mozilla.dom.util;
-
-import java.io.BufferedOutputStream;
-import java.io.PrintStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-import org.w3c.dom.Document;
-import org.w3c.dom.DocumentType;
-import org.w3c.dom.Element;
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
-public class DOMTreeDumper {
-
-    private String name;
-    private boolean debug;
-    private PrintStream ps;
-    private boolean inA;
-    private final String[] endTagForbiddenNames = {"AREA",    
-						   "BASE",    
-						   "BASEFONT",
-						   "BR",      
-						   "COL",     
-						   "FRAME",   
-						   "HR",      
-						   "IMG",     
-						   "INPUT",   
-						   "ISINDEX", 
-						   "LINK",    
-						   "META",    
-						   "PARAM"};
-    
-    public DOMTreeDumper() {
-	this("DOMTreeDumper", true);
-    }
-
-    public DOMTreeDumper(boolean debug) {
-	this("DOMTreeDumper", debug);
-    }
-
-    public DOMTreeDumper(String name) {
-	this(name, true);
-    }
-
-    public DOMTreeDumper(String name, boolean debug) {
-	this.name = name;
-	this.debug = debug;
-    }
-
-    private void dumpDocument(Document doc) {
-	if (doc == null) return;
-	Element element = doc.getDocumentElement();
-	if (element == null) return;
-	element.normalize();
-//  	DocumentType dt = doc.getDoctype();
-//  	dumpNode(dt);
-	
-	dumpNode(element);
-	ps.println();
-	ps.flush();
-	
-	element = null;
-	doc = null;
-    }
-
-    private void dumpNode(Node node) {
-	dumpNode(node, false);
-    }
-
-    private void dumpNode(Node node, boolean isMapNode) {
-	if (node == null) {
-	    return;
-	}
-
-	int type = node.getNodeType();
-	String name = node.getNodeName();
-	String value = node.getNodeValue();
-
-	switch (type) {
-	case Node.ELEMENT_NODE: 
-	    if (name.equals("A")) inA = true;
-	    if (!(inA || name.equals("BR"))) {
-		ps.println();
-	    }
-	    ps.print("<" + name);
-	    dumpAttributes(node);
-	    ps.print(">");	
-	    dumpChildren(node);
-	    if (name.equals("A")) inA = false;
-	    if (!endTagForbidden(name)) {
-		ps.print("</" + node.getNodeName() + ">");	
-	    }
-	    break;
-	case Node.ATTRIBUTE_NODE: 
-	    ps.print(" " + name.toUpperCase() + "=\"" + value + "\"");
-	    break;
-	case Node.TEXT_NODE: 
-	    if (!node.getParentNode().getNodeName().equals("PRE")) {
-		value = value.trim();
-	    }
-	    if (!value.equals("")) {
-		if (!inA) {
-		    ps.println();
-		}
-		ps.print(canonicalize(value));
-	    }
-	    break;	
-	case Node.COMMENT_NODE:
-	    ps.print("\n<!--" + value + "-->");
-	    break;
-	case Node.CDATA_SECTION_NODE:
-	case Node.ENTITY_REFERENCE_NODE:
-	case Node.ENTITY_NODE:
-	case Node.PROCESSING_INSTRUCTION_NODE:
-	case Node.DOCUMENT_NODE:
-	case Node.DOCUMENT_TYPE_NODE:
-	case Node.DOCUMENT_FRAGMENT_NODE:
-	case Node.NOTATION_NODE:
-	    ps.println("\n<!-- NOT HANDLED: " + name + 
-		       "  value=" + value + " -->");
-	    break;
-	}	
-    }
-    
-    private void dumpAttributes(Node node) {
-	NamedNodeMap map = node.getAttributes();
-	if (map == null) return;
-	int length = map.getLength();
-	for (int i=0; i < length; i++) {
-	    Node item = map.item(i);
-	    dumpNode(item, true);
-	}
-    }
-    
-    private void dumpChildren(Node node) {
-	NodeList children = node.getChildNodes();
-	int length = 0;
-	boolean hasChildren = ((children != null) && ((length = children.getLength()) > 0));
-	if (!hasChildren) { 
-	    return;
-	}
-	for (int i=0; i < length; i++) {
-	    dumpNode(children.item(i), false);
-	}
-	if (!inA) {
-	    ps.println();
-	}
-    }
-
-    private String canonicalize(String str) {
-	StringBuffer in = new StringBuffer(str);
-	int length = in.length();
-	StringBuffer out = new StringBuffer(length);
-	char c;
-	for (int i = 0; i < length; i++) {
-	    switch (c = in.charAt(i)) {  			
-	    case '&' :
-		out.append("&amp;");
-		break;
-	    case '<':
-		out.append("&lt;");
-		break;
-	    case '>':
-		out.append("&gt;");
-		break;
-	    case '\u00A0':
-		out.append("&nbsp;");
-		break;
-	    default:
-		out.append(c);
-	    }
-	}
-	return out.toString();
-    }
-
-    private boolean endTagForbidden(String name) {
-	for (int i = 0; i < endTagForbiddenNames.length; i++) {
-	    if (name.equals(endTagForbiddenNames[i])) {
-		return true;
-	    }
-	}
-	return false;
-    }
-
-    public void dumpToFile(String fileName, Document doc) {
-	try {
-	    FileOutputStream fos = new FileOutputStream(fileName);
-	    ps = new PrintStream(new BufferedOutputStream(fos, 1024));
-	} catch (IOException ex) {
-	    ex.printStackTrace();
-	    return;
-	}	
-	dbg("dumping to " + fileName);	
-	dumpDocument(doc);
-	dbg("finished dumping...");	
-    }
-
-    public void dumpToStream(PrintStream ps, Document doc) {
-	this.ps = ps;
-	dbg("dumping to stream...");	
-	dumpDocument(doc);
-	dbg("finished dumping...");	
-    }
-
-    private void dbg(String str) {
-	if (debug) {
-	    System.out.println(name + ": " + str);
-	}
-    }
-}

mozilla/java/dom/classes/org/mozilla/dom/util/GenericDocLoadListener.java

@@ -1,105 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-package org.mozilla.dom.util;
-
-import java.io.PrintStream;
-import org.w3c.dom.Document;
-import org.mozilla.dom.DocumentLoadListener;
-
-public class GenericDocLoadListener implements DocumentLoadListener {
-
-    private String name;
-    private PrintStream ps;
-
-    public GenericDocLoadListener() {
-	this("GenericDocLoadListener", 
-	     new PrintStream(System.out));
-    }
-
-    public GenericDocLoadListener(String name) {
-	this(name, 
-	    new PrintStream(System.out));
-    }
-
-    public GenericDocLoadListener(PrintStream ps) {
-	this("GenericDocLoadListener", ps);
-    }
-
-    public GenericDocLoadListener(String name, PrintStream ps) {
-	this.name = name;
-	this.ps = ps;	
-    }
-
-    public DocumentLoadListener getDocumentLoadListener() {
-	return this;
-    }
-
-    public void startURLLoad(String url, String contentType, Document doc) {
-	if (ps != null) {
-	    ps.println(name + " :start URL load - " + 
-			       url.toString() + " " + 
-			       contentType);
-	}
-    }
-
-    public void endURLLoad(String url, int status, Document doc) {
-	
-	if (ps != null) {
-	    ps.println(name + " :end URL load - " + 
-			       url.toString() + " " +
-			       Integer.toHexString(status));
-	}
-    }
-    
-    public void progressURLLoad(String url, int progress, int progressMax,
-				Document doc) {
-	if (ps != null) {
-	    ps.println(name + " :progress URL load - " + 
-			       url.toString() + " " +
-			       Integer.toString(progress) + "/" +
-			       Integer.toString(progressMax));
-	}
-    }
-    
-    public void statusURLLoad(String url, String message, Document doc) {
-	if (ps != null) {
-	    ps.println(name + " :status URL load - " + 
-			       url.toString() + " (" +
-			       message + ")");
-	}
-    }
-
-    public void startDocumentLoad(String url) {
-	if (ps != null) {
-	    ps.println(name + " :start doc load - " + 
-			       url.toString());
-	}
-    }
-
-    public void endDocumentLoad(String url, int status, Document doc) {
-	if (ps != null) {
-	    ps.println(name + " :end doc load - " + 
-			       url.toString() + " " + 
-			       Integer.toHexString(status));
-	} 
-    }
-}

mozilla/java/dom/classes/org/mozilla/dom/util/GenericEventListener.java

@@ -1,68 +0,0 @@
-/* 
- * The contents of this file are subject to the Mozilla Public License
- * Version 1.0 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/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 Initial Developer of the Original Code is Sun Microsystems,
- * Inc. Portions created by Sun are Copyright (C) 1999 Sun Microsystems,
- * Inc. All Rights Reserved. 
- *
- * Contributor(s):
- *
- */
-package org.mozilla.dom.util;
-
-import java.io.PrintStream;
-import org.w3c.dom.events.Event;
-import org.w3c.dom.events.EventListener;
-
-public class GenericEventListener implements EventListener {
-
-    private String name;
-    private PrintStream ps;
-
-    public GenericEventListener() {
-	this("GenericEventListener", 
-	     new PrintStream(System.out));
-    }
-
-    public GenericEventListener(String name) {
-	this(name, new PrintStream(System.out));
-    }
-
-    public GenericEventListener(PrintStream ps) {
-	this("GenericEventListener", ps);
-    }
-
-    public GenericEventListener(String name, PrintStream ps) {
-	this.name = name;
-	this.ps = ps;	
-    }
-
-    /**
-     * This method is called whenever an event occurs of the type for which the 
-     * <code> EventListener</code> interface was registered. 
-     * @param event The <code>Event</code> contains contextual information about 
-     *   the event.  It also contains the <code>returnValue</code> and 
-     *   <code>cancelBubble</code> properties which are used in determining 
-     *   proper event flow.
-     */
-    public void handleEvent(Event event) {
-	try {
-	    if (ps != null) {
-		ps.println(name + ": got event " + event);
-	    }
-	} catch (Exception e) {
-	    if (ps != null) {
-		ps.println(name + ": exception in handleEvent " + e);
-	    }
-	}
-    }
-}
-

mozilla/java/dom/jni/Makefile

@@ -1,84 +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 Sun Microsystems,
-# Inc. Portions created by Sun are
-# Copyright (C) 1999 Sun Microsystems, Inc. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH		= ../../..
-topsrcdir	= $(DEPTH)
-srcdir		= $(topsrcdir)/java/dom/jni
-VPATH		= $(topsrcdir)/java/dom/jni
-
-JAVAHOME        = $(JDKHOME)
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME	= javadomjni
-
-CPPSRCS		= \
-	javaDOMGlobals.cpp \
-	javaDOMEventsGlobals.cpp \
-	nativeDOMProxyListener.cpp \
-	org_mozilla_dom_DOMAccessor.cpp \
-	org_mozilla_dom_AttrImpl.cpp \
-	org_mozilla_dom_CharacterDataImpl.cpp \
-	org_mozilla_dom_DocumentImpl.cpp \
-	org_mozilla_dom_DocumentTypeImpl.cpp \
-	org_mozilla_dom_DOMImplementationImpl.cpp \
-	org_mozilla_dom_ElementImpl.cpp \
-	org_mozilla_dom_EntityImpl.cpp \
-	org_mozilla_dom_NamedNodeMapImpl.cpp \
-	org_mozilla_dom_NodeImpl.cpp \
-	org_mozilla_dom_NodeListImpl.cpp \
-	org_mozilla_dom_NotationImpl.cpp \
-	org_mozilla_dom_ProcessingInstructionImpl.cpp \
-	org_mozilla_dom_TextImpl.cpp \
-	org_mozilla_dom_events_EventImpl.cpp \
-	org_mozilla_dom_events_UIEventImpl.cpp \
-	org_mozilla_dom_events_MouseEventImpl.cpp 
-
-include $(topsrcdir)/config/config.mk
-
-include $(topsrcdir)/config/rules.mk
-
-JAVA_CLS= \
-	org.mozilla.dom.DOMAccessor \
-	org.mozilla.dom.AttrImpl \
-	org.mozilla.dom.CharacterDataImpl \
-	org.mozilla.dom.DocumentImpl \
-	org.mozilla.dom.DocumentTypeImpl \
-	org.mozilla.dom.DOMImplementationImpl \
-	org.mozilla.dom.ElementImpl \
-	org.mozilla.dom.EntityImpl \
-	org.mozilla.dom.NamedNodeMapImpl \
-	org.mozilla.dom.NodeImpl \
-	org.mozilla.dom.NodeListImpl \
-	org.mozilla.dom.NotationImpl \
-	org.mozilla.dom.ProcessingInstructionImpl \
-	org.mozilla.dom.TextImpl \
-	org.mozilla.dom.events.EventImpl \
-	org.mozilla.dom.events.MouseEventImpl \
-	org.mozilla.dom.events.UIEventImpl \
- $(NULL)
-
-JAVAH_PROG=$(JDKHOME)/bin/javah
-JAVAH_FLAGS=-jni -classpath $(CLASSPATH):$(JAVA_DESTPATH)
-
-export::
-	$(JAVAH_PROG) $(JAVAH_FLAGS) $(JAVA_CLS)
-
-clobber::
-	rm -f org_*.h

mozilla/java/dom/jni/Makefile.in

@@ -1,84 +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 Sun Microsystems,
-# Inc. Portions created by Sun are
-# Copyright (C) 1999 Sun Microsystems, Inc. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH		= ../../..
-topsrcdir	= $(DEPTH)
-srcdir		= $(topsrcdir)/java/dom/jni
-VPATH		= $(topsrcdir)/java/dom/jni
-
-JAVAHOME        = $(JDKHOME)
-
-include $(DEPTH)/config/autoconf.mk
-
-LIBRARY_NAME	= javadomjni
-
-CPPSRCS		= \
-	javaDOMGlobals.cpp \
-	javaDOMEventsGlobals.cpp \
-	nativeDOMProxyListener.cpp \
-	org_mozilla_dom_DOMAccessor.cpp \
-	org_mozilla_dom_AttrImpl.cpp \
-	org_mozilla_dom_CharacterDataImpl.cpp \
-	org_mozilla_dom_DocumentImpl.cpp \
-	org_mozilla_dom_DocumentTypeImpl.cpp \
-	org_mozilla_dom_DOMImplementationImpl.cpp \
-	org_mozilla_dom_ElementImpl.cpp \
-	org_mozilla_dom_EntityImpl.cpp \
-	org_mozilla_dom_NamedNodeMapImpl.cpp \
-	org_mozilla_dom_NodeImpl.cpp \
-	org_mozilla_dom_NodeListImpl.cpp \
-	org_mozilla_dom_NotationImpl.cpp \
-	org_mozilla_dom_ProcessingInstructionImpl.cpp \
-	org_mozilla_dom_TextImpl.cpp \
-	org_mozilla_dom_events_EventImpl.cpp \
-	org_mozilla_dom_events_UIEventImpl.cpp \
-	org_mozilla_dom_events_MouseEventImpl.cpp
-
-include $(topsrcdir)/config/config.mk
-
-include $(topsrcdir)/config/rules.mk
-
-JAVA_CLS= \
-	org.mozilla.dom.DOMAccessor \
-	org.mozilla.dom.AttrImpl \
-	org.mozilla.dom.CharacterDataImpl \
-	org.mozilla.dom.DocumentImpl \
-	org.mozilla.dom.DocumentTypeImpl \
-	org.mozilla.dom.DOMImplementationImpl \
-	org.mozilla.dom.ElementImpl \
-	org.mozilla.dom.EntityImpl \
-	org.mozilla.dom.NamedNodeMapImpl \
-	org.mozilla.dom.NodeImpl \
-	org.mozilla.dom.NodeListImpl \
-	org.mozilla.dom.NotationImpl \
-	org.mozilla.dom.ProcessingInstructionImpl \
-	org.mozilla.dom.TextImpl \
-	org.mozilla.dom.events.EventImpl \
-	org.mozilla.dom.events.MouseEventImpl \
-	org.mozilla.dom.events.UIEventImpl \
- $(NULL)
-
-JAVAH_PROG=$(JDKHOME)/bin/javah
-JAVAH_FLAGS=-jni -classpath $(CLASSPATH):$(JAVA_DESTPATH)
-
-export::
-	$(JAVAH_PROG) $(JAVAH_FLAGS) $(JAVA_CLS)
-
-clobber::
-	rm -f org_*.h

mozilla/java/dom/jni/javaDOMEventsGlobals.cpp

@@ -1,268 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "prmon.h"
-#include "nsAutoLock.h"
-#include "javaDOMEventsGlobals.h"
-#include "nsIDOMEvent.h"
-#include "nsIDOMUIEvent.h"
-
-jclass JavaDOMEventsGlobals::eventClass = NULL;
-jclass JavaDOMEventsGlobals::uiEventClass = NULL;
-jclass JavaDOMEventsGlobals::eventListenerClass = NULL;
-jclass JavaDOMEventsGlobals::eventTargetClass = NULL;
-jclass JavaDOMEventsGlobals::mouseEventClass = NULL;
-jclass JavaDOMEventsGlobals::mutationEventClass = NULL;
-
-jfieldID JavaDOMEventsGlobals::eventPtrFID = NULL;
-jfieldID JavaDOMEventsGlobals::eventTargetPtrFID = NULL;
-
-jfieldID JavaDOMEventsGlobals::eventPhaseBubblingFID = NULL;
-jfieldID JavaDOMEventsGlobals::eventPhaseCapturingFID = NULL;
-jfieldID JavaDOMEventsGlobals::eventPhaseAtTargetFID = NULL;
-
-jmethodID JavaDOMEventsGlobals::eventListenerHandleEventMID = NULL;
-
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-static NS_DEFINE_IID(kIDOMUIEventIID, NS_IDOMUIEVENT_IID);
-
-void JavaDOMEventsGlobals::Initialize(JNIEnv *env) 
-{
-  eventClass = env->FindClass("org/mozilla/dom/events/EventImpl");
-  if (!eventClass) {
-      JavaDOMGlobals::ThrowException(env, "Class org.mozilla.dom.events.EventImpl not found");
-      return;
-  }
-  eventClass = (jclass) env->NewGlobalRef(eventClass);
-  if (!eventClass) 
-      return;
-  eventPtrFID = 
-      env->GetFieldID(eventClass, "p_nsIDOMEvent", "J");
-  if (!eventPtrFID) {
-      JavaDOMGlobals::ThrowException(env, "There is no field p_nsIDOMEvent in org.mozilla.dom.events.EventImpl"); 
-      return;
-  }
-  
-  eventListenerClass = env->FindClass("org/w3c/dom/events/EventListener");
-  if (!eventListenerClass) {
-      JavaDOMGlobals::ThrowException(env, "Class org.w3c.dom.events.EventListener not found");
-      return;
-  }
-  eventListenerClass = (jclass) env->NewGlobalRef(eventListenerClass);
-  if (!eventListenerClass) 
-      return;
-
-  eventListenerHandleEventMID = env->GetMethodID(
-                         eventListenerClass, "handleEvent", "(Lorg/w3c/dom/events/Event;)V");
-  if (!eventListenerHandleEventMID) {
-      JavaDOMGlobals::ThrowException(env, "There is no method handleEvent in org.w3c.dom.events.EventListener"); 
-      return;
-  }
-
-  uiEventClass = env->FindClass("org/mozilla/dom/events/UIEventImpl");
-  if (!uiEventClass) {
-      JavaDOMGlobals::ThrowException(env, "Class org.mozilla.dom.events.UIEventImpl not found");
-      return;
-  }
-  uiEventClass = (jclass) env->NewGlobalRef(uiEventClass);
-  if (!uiEventClass) 
-      return;
-
-  eventPhaseBubblingFID = 
-    env->GetStaticFieldID(eventClass, "BUBBLING_PHASE", "S");
-  if (!eventPhaseBubblingFID) {
-      JavaDOMGlobals::ThrowException(env, "There is no static field BUBBLING_PHASE in org.w3c.dom.events.Event"); 
-      return;
-  }
-
-  eventPhaseCapturingFID = 
-    env->GetStaticFieldID(eventClass, "CAPTURING_PHASE", "S");
-  if (!eventPhaseCapturingFID) {
-      JavaDOMGlobals::ThrowException(env, "There is no static field CAPTURING_PHASE in org.w3c.dom.events.Event"); 
-      return;
-  }
-
-  eventPhaseAtTargetFID = 
-    env->GetStaticFieldID(eventClass, "AT_TARGET", "S");
-  if (!eventPhaseAtTargetFID) {
-      JavaDOMGlobals::ThrowException(env, "There is no static field AT_TARGET in org.w3c.dom.events.Event"); 
-      return;
-  }
-
-  mouseEventClass = env->FindClass("org/mozilla/dom/events/MouseEventImpl");
-  if (!mouseEventClass) {
-      JavaDOMGlobals::ThrowException(env, "Class org.mozilla.dom.events.MouseEventImpl not found");
-      return;
-  }
-  mouseEventClass = (jclass) env->NewGlobalRef(mouseEventClass);
-  if (!mouseEventClass) 
-      return;
-}
-
-void JavaDOMEventsGlobals::Destroy(JNIEnv *env) 
-{
-  env->DeleteGlobalRef(eventClass);
-  if (env->ExceptionOccurred()) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-          ("JavaDOMEventsGlobals::Destroy: failed to delete Event global ref %x\n", 
-            eventClass));
-      return;
-  }
-  eventClass = NULL;
-
-  env->DeleteGlobalRef(eventListenerClass);
-  if (env->ExceptionOccurred()) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-          ("JavaDOMEventsGlobals::Destroy: failed to delete EventListener global ref %x\n", 
-           eventListenerClass));
-      return;
-  }
-  eventListenerClass = NULL;
-
-  env->DeleteGlobalRef(uiEventClass);
-  if (env->ExceptionOccurred()) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-           ("JavaDOMEventsGlobals::Destroy: failed to delete UIEvent global ref %x\n", 
-            uiEventClass));
-      return;
-  }
-  uiEventClass = NULL;
-
-  env->DeleteGlobalRef(mouseEventClass);
-  if (env->ExceptionOccurred()) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-           ("JavaDOMEventsGlobals::Destroy: failed to delete mouseEvent global ref %x\n", 
-            mouseEventClass));
-      return;
-  }
-  mouseEventClass = NULL;
-
-}
-
-//returns true if specified event "type" exists in the given list of types
-// NOTE: it is assumed that "types" list is enden with NULL
-static jboolean isEventOfType(const char* const* types, const char* type) 
-{
-    int i=0;
-
-    while (type && types && types[i]) {
-      if (!strcmp(type,types[i]))
-	return JNI_TRUE;
-      i++;
-    }
-
-    return JNI_FALSE;
-}
-
-jobject JavaDOMEventsGlobals::CreateEventSubtype(JNIEnv *env, 
-                      nsIDOMEvent *event) 
-{
-  jobject jevent;
-  jclass clazz = eventClass;
-  nsISupports *isupports;
-  void *target;
-  nsresult rv;
-  
-  isupports = (nsISupports *) event;
-
-  //check whenever our Event is UIEvent
-  rv = isupports->QueryInterface(kIDOMUIEventIID, (void **) &target);
-  if (!NS_FAILED(rv) && target) {
-    // At the moment DOM2 draft specifies set of UIEvent subclasses 
-    // However Mozilla still presents these events as nsUIEvent
-    // So we need a cludge to determine proper java class to be created
-    
-    static const char* const uiEventTypes[] = { 
-      "resize", 
-      "scroll", 
-      "focusin", 
-      "focusout", 
-      "gainselection",
-      "loseselection", 
-      "activate", 
-      NULL
-    };
-  
-    static const char* const mouseEventTypes[] = { 
-      "click", 
-      "mousedown",
-      "mouseup", 
-      "mouseover",
-      "mousemove", 
-      "mouseout", 
-      NULL
-    };
-  
-    nsString eventType;
-    rv = event->GetType(eventType);
-    if (NS_FAILED(rv)) {
-        JavaDOMGlobals::ThrowException(env,
-            "Event.getType at JavaDOMEventsGlobals: failed");
-        return NULL;
-    }
-
-    char* buffer = nsnull;
-    if (eventType.IsUnicode()) {
-      buffer = eventType.ToNewUTF8String();
-    } else {
-      buffer = eventType.ToNewCString();
-    }
-
-    if (isEventOfType(mouseEventTypes, buffer) == JNI_TRUE) {
-      clazz = mouseEventClass;
-    } else if (isEventOfType(uiEventTypes, buffer) == JNI_TRUE) {  
-      clazz = uiEventClass;
-    } else {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING,
-	     ("Unknown type of UI event (%s)", buffer));
-
-      clazz = uiEventClass;
-    }
-    nsString::Recycle(&eventType);
-
-    event->Release();
-    event = (nsIDOMEvent *) target;
-  }
-
-  PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-      ("JavaDOMEventsGlobals::CreateEventSubtype: allocating Node of  clazz=%x\n", 
-       clazz));
-
-  jevent = env->AllocObject(clazz);
-  if (!jevent) {
-        JavaDOMGlobals::ThrowException(env,
-            "JavaDOMEventsGlobals::CreateEventSubtype: failed to allocate Event object");
-      return NULL;
-  }
-
-  env->SetLongField(jevent, eventPtrFID, (jlong) event);
-  if (env->ExceptionOccurred()) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	      ("JavaDOMEventGlobals::CreateEventSubtype: failed to set native ptr %x\n", 
-	      (jlong) event));
-      return NULL;
-  }
-  event->AddRef();
-
-  return jevent;
-}
-

mozilla/java/dom/jni/javaDOMEventsGlobals.h

@@ -1,56 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#ifndef __JavaDOMEventsGlobals_h__
-#define __JavaDOMEventsGlobals_h__
-
-#include"javaDOMGlobals.h"
-#include"nsIDOMEvent.h"
-
-class JavaDOMEventsGlobals {
-
- public:
-  static jclass eventClass;
-  static jclass eventListenerClass;
-  static jclass eventTargetClass;
-  static jclass uiEventClass;
-  static jclass mutationEventClass;
-  static jclass mouseEventClass;
-  
-  static jfieldID eventPtrFID;
-  static jfieldID eventTargetPtrFID;
-
-  static jfieldID eventPhaseBubblingFID;
-  static jfieldID eventPhaseCapturingFID;
-  static jfieldID eventPhaseAtTargetFID;   
-
-  static jmethodID eventListenerHandleEventMID;
-
-  static void Initialize(JNIEnv *env);
-  static void Destroy(JNIEnv *env);
-  static jobject CreateEventSubtype(JNIEnv *env, 
-				   nsIDOMEvent *event);
-
-  static jlong RegisterNativeEventListener();
-  static jlong UnregisterNativeEventListener();
-};
-
-#endif /* __JavaDOMEventsGlobals_h__ */

mozilla/java/dom/jni/javaDOMGlobals.cpp

@@ -1,626 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "prmon.h"
-#include "nsAutoLock.h"
-#include "nsIDOMNode.h"
-#include "javaDOMGlobals.h"
-#include "javaDOMEventsGlobals.h"
-
-jclass JavaDOMGlobals::attrClass = NULL;
-jclass JavaDOMGlobals::cDataSectionClass = NULL;
-jclass JavaDOMGlobals::commentClass = NULL;
-jclass JavaDOMGlobals::documentClass = NULL;
-jclass JavaDOMGlobals::documentFragmentClass = NULL;
-jclass JavaDOMGlobals::documentTypeClass = NULL;
-jclass JavaDOMGlobals::domImplementationClass = NULL;
-jclass JavaDOMGlobals::elementClass = NULL;
-jclass JavaDOMGlobals::entityClass = NULL;
-jclass JavaDOMGlobals::entityReferenceClass = NULL;
-jclass JavaDOMGlobals::namedNodeMapClass = NULL;
-jclass JavaDOMGlobals::nodeClass = NULL;
-jclass JavaDOMGlobals::nodeListClass = NULL;
-jclass JavaDOMGlobals::notationClass = NULL;
-jclass JavaDOMGlobals::processingInstructionClass = NULL;
-jclass JavaDOMGlobals::textClass = NULL;
-
-jfieldID JavaDOMGlobals::nodePtrFID = NULL;
-jfieldID JavaDOMGlobals::nodeListPtrFID = NULL;
-jfieldID JavaDOMGlobals::domImplementationPtrFID = NULL;
-jfieldID JavaDOMGlobals::namedNodeMapPtrFID = NULL;
-
-jfieldID JavaDOMGlobals::nodeTypeAttributeFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeCDataSectionFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeCommentFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeDocumentFragmentFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeDocumentFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeDocumentTypeFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeElementFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeEntityFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeEntityReferenceFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeNotationFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeProcessingInstructionFID = NULL;
-jfieldID JavaDOMGlobals::nodeTypeTextFID = NULL;
-
-jclass JavaDOMGlobals::domExceptionClass = NULL;
-jmethodID JavaDOMGlobals::domExceptionInitMID = NULL;
-jclass JavaDOMGlobals::runtimeExceptionClass = NULL;
-jmethodID JavaDOMGlobals::runtimeExceptionInitMID = NULL;
-
-const char* const JavaDOMGlobals::DOM_EXCEPTION_MESSAGE[] = 
-  {"Invalid DOM error code",
-   "Index is out of bounds",
-   "Could not fit text",
-   "Wrong hierarchy request",
-   "Wrong document usage",
-   "Invalid character",
-   "Data is unsupported",
-   "Modification disallowed",
-   "Node not found",
-   "Type is unsupported",
-   "Attribute is alreay in use", 
-   "Invalid state",
-   "Syntax error",
-   "Invalid modification",
-   "Namespace error",
-   "Invalid access"};
-
-PRLogModuleInfo* JavaDOMGlobals::log = NULL;
-
-PRCList JavaDOMGlobals::garbage = PR_INIT_STATIC_CLIST(&garbage);
-PRLock* JavaDOMGlobals::garbageLock = NULL;
-
-PRInt32 JavaDOMGlobals::javaMaxInt = 0;
-
-class jniDOMGarbage : public PRCList {
-public:
-  jniDOMGarbage(nsISupports* p) { domObject = p; }
-  nsISupports* domObject;
-};
-
-void JavaDOMGlobals::Initialize(JNIEnv *env) 
-{
-  garbageLock = PR_NewLock();
-  log = PR_NewLogModule("javadom");
-  PR_INIT_CLIST(&garbage);
-
-  /* Node is loaded first because it is the base class of a lot of the
-     others */
-  nodeClass = env->FindClass("org/mozilla/dom/NodeImpl");
-  if (!nodeClass) return;
-  nodeClass = (jclass) env->NewGlobalRef(nodeClass);
-  if (!nodeClass) return;
-  nodePtrFID = 
-    env->GetFieldID(nodeClass, "p_nsIDOMNode", "J");
-  if (!nodePtrFID) return;
-
-  attrClass = env->FindClass("org/mozilla/dom/AttrImpl");
-  if (!attrClass) return;
-  attrClass = (jclass) env->NewGlobalRef(attrClass);
-  if (!attrClass) return;
-
-  cDataSectionClass = env->FindClass("org/mozilla/dom/CDATASectionImpl");
-  if (!cDataSectionClass) return;
-  cDataSectionClass = (jclass) env->NewGlobalRef(cDataSectionClass);
-  if (!cDataSectionClass) return;
-
-  commentClass = env->FindClass("org/mozilla/dom/CommentImpl");
-  if (!commentClass) return;
-  commentClass = (jclass) env->NewGlobalRef(commentClass);
-  if (!commentClass) return;
-
-  documentClass = env->FindClass("org/mozilla/dom/DocumentImpl");
-  if (!documentClass) return;
-  documentClass = (jclass) env->NewGlobalRef(documentClass);
-  if (!documentClass) return;
-
-  documentFragmentClass = env->FindClass("org/mozilla/dom/DocumentFragmentImpl");
-  if (!documentFragmentClass) return;
-  documentFragmentClass = (jclass) env->NewGlobalRef(documentFragmentClass);
-  if (!documentFragmentClass) return;
-
-  documentTypeClass = env->FindClass("org/mozilla/dom/DocumentTypeImpl");
-  if (!documentTypeClass) return;
-  documentTypeClass = (jclass) env->NewGlobalRef(documentTypeClass);
-  if (!documentTypeClass) return;
-
-  domImplementationClass = env->FindClass("org/mozilla/dom/DOMImplementationImpl");
-  if (!domImplementationClass) return;
-  domImplementationClass = (jclass) env->NewGlobalRef(domImplementationClass);
-  if (!domImplementationClass) return;
-  domImplementationPtrFID = 
-    env->GetFieldID(domImplementationClass, "p_nsIDOMDOMImplementation", "J");
-  if (!domImplementationPtrFID) return;
-
-  elementClass = env->FindClass("org/mozilla/dom/ElementImpl");
-  if (!elementClass) return;
-  elementClass = (jclass) env->NewGlobalRef(elementClass);
-  if (!elementClass) return;
-
-  entityClass = env->FindClass("org/mozilla/dom/EntityImpl");
-  if (!entityClass) return;
-  entityClass = (jclass) env->NewGlobalRef(entityClass);
-  if (!entityClass) return;
-
-  entityReferenceClass = env->FindClass("org/mozilla/dom/EntityReferenceImpl");
-  if (!entityReferenceClass) return;
-  entityReferenceClass = (jclass) env->NewGlobalRef(entityReferenceClass);
-  if (!entityReferenceClass) return;
-
-  namedNodeMapClass = env->FindClass("org/mozilla/dom/NamedNodeMapImpl");
-  if (!namedNodeMapClass) return;
-  namedNodeMapPtrFID = 
-    env->GetFieldID(namedNodeMapClass, "p_nsIDOMNamedNodeMap", "J");
-  if (!namedNodeMapPtrFID) return;
-  namedNodeMapClass = (jclass) env->NewGlobalRef(namedNodeMapClass);
-  if (!namedNodeMapClass) return;
-
-  nodeListClass = env->FindClass("org/mozilla/dom/NodeListImpl");
-  if (!nodeListClass) return;
-  nodeListClass = (jclass) env->NewGlobalRef(nodeListClass);
-  if (!nodeListClass) return;
-  nodeListPtrFID = 
-    env->GetFieldID(nodeListClass, "p_nsIDOMNodeList", "J");
-  if (!nodeListPtrFID) return;
-
-  nodeTypeAttributeFID = 
-    env->GetStaticFieldID(nodeClass, "ATTRIBUTE_NODE", "S");
-  if (!nodeTypeAttributeFID) return;
-  nodeTypeCDataSectionFID = 
-    env->GetStaticFieldID(nodeClass, "CDATA_SECTION_NODE", "S");
-  if (!nodeTypeCDataSectionFID) return;
-  nodeTypeCommentFID = 
-    env->GetStaticFieldID(nodeClass, "COMMENT_NODE", "S");
-  if (!nodeTypeCommentFID) return;
-  nodeTypeDocumentFragmentFID = 
-    env->GetStaticFieldID(nodeClass, "DOCUMENT_FRAGMENT_NODE", "S");
-  if (!nodeTypeDocumentFragmentFID) return;
-  nodeTypeDocumentFID = 
-    env->GetStaticFieldID(nodeClass, "DOCUMENT_NODE", "S");
-  if (!nodeTypeDocumentFID) return;
-  nodeTypeDocumentTypeFID = 
-    env->GetStaticFieldID(nodeClass, "DOCUMENT_TYPE_NODE", "S");
-  if (!nodeTypeDocumentTypeFID) return;
-  nodeTypeElementFID = 
-    env->GetStaticFieldID(nodeClass, "ELEMENT_NODE", "S");
-  if (!nodeTypeElementFID) return;
-  nodeTypeEntityFID = 
-    env->GetStaticFieldID(nodeClass, "ENTITY_NODE", "S");
-  if (!nodeTypeEntityFID) return;
-  nodeTypeEntityReferenceFID = 
-    env->GetStaticFieldID(nodeClass, "ENTITY_REFERENCE_NODE", "S");
-  if (!nodeTypeEntityReferenceFID) return;
-  nodeTypeNotationFID = 
-    env->GetStaticFieldID(nodeClass, "NOTATION_NODE", "S");
-  if (!nodeTypeNotationFID) return;
-  nodeTypeProcessingInstructionFID = 
-    env->GetStaticFieldID(nodeClass, "PROCESSING_INSTRUCTION_NODE", "S");
-  if (!nodeTypeProcessingInstructionFID) return;
-  nodeTypeTextFID = 
-    env->GetStaticFieldID(nodeClass, "TEXT_NODE", "S");
-  if (!nodeTypeTextFID) return;
-
-  notationClass = env->FindClass("org/mozilla/dom/NotationImpl");
-  if (!notationClass) return;
-  notationClass = (jclass) env->NewGlobalRef(notationClass);
-  if (!notationClass) return;
-
-  processingInstructionClass = env->FindClass("org/mozilla/dom/ProcessingInstructionImpl");
-  if (!processingInstructionClass) return;
-  processingInstructionClass = (jclass) env->NewGlobalRef(processingInstructionClass);
-  if (!processingInstructionClass) return;
-
-  textClass = env->FindClass("org/mozilla/dom/TextImpl");
-  if (!textClass) return;
-  textClass = (jclass) env->NewGlobalRef(textClass);
-  if (!textClass) return;
-
-  domExceptionClass = env->FindClass("org/mozilla/dom/DOMExceptionImpl");
-  if (!domExceptionClass) return;
-  domExceptionClass = (jclass) env->NewGlobalRef(domExceptionClass);
-  if (!domExceptionClass) return;
-
-  domExceptionInitMID = 
-    env->GetMethodID(domExceptionClass, "<init>", "(SLjava/lang/String;)V");
-  if (!domExceptionInitMID) return;
-
-  runtimeExceptionClass = env->FindClass("java/lang/RuntimeException");
-  if (!runtimeExceptionClass) return;
-  runtimeExceptionClass = (jclass) env->NewGlobalRef(runtimeExceptionClass);
-  if (!runtimeExceptionClass) return;
-
-  runtimeExceptionInitMID = 
-    env->GetMethodID(runtimeExceptionClass, "<init>", "(Ljava/lang/String;)V");
-  if (!runtimeExceptionInitMID) return;
-
-
-  jclass integerClass = env->FindClass("java/lang/Integer");
-  jfieldID javaMaxIntFID = 
-    env->GetStaticFieldID(integerClass, "MAX_VALUE", "I");
-  javaMaxInt = env->GetStaticIntField(integerClass, javaMaxIntFID);
-
-  //init events globals
-  JavaDOMEventsGlobals::Initialize(env);
-}
-
-void JavaDOMGlobals::Destroy(JNIEnv *env) 
-{
-  //destroy events stuff
-  JavaDOMEventsGlobals::Destroy(env);
-
-  env->DeleteGlobalRef(attrClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Attr global ref %x\n", 
-	    attrClass));
-    return;
-  }
-  attrClass = NULL;
-
-  env->DeleteGlobalRef(cDataSectionClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete CDATASection global ref %x\n", 
-	    cDataSectionClass));
-    return;
-  }
-  cDataSectionClass = NULL;
-
-  env->DeleteGlobalRef(commentClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Comment global ref %x\n", 
-	    commentClass));
-    return;
-  }
-  commentClass = NULL;
-
-  env->DeleteGlobalRef(documentClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Document global ref %x\n", 
-	    documentClass));
-    return;
-  }
-  documentClass = NULL;
-
-  env->DeleteGlobalRef(documentFragmentClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete DocumentFragment global ref %x\n", 
-	    documentFragmentClass));
-    return;
-  }
-  documentFragmentClass = NULL;
-
-  env->DeleteGlobalRef(documentTypeClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete DocumentType global ref %x\n", 
-	    documentTypeClass));
-    return;
-  }
-  documentTypeClass = NULL;
-
-  env->DeleteGlobalRef(domImplementationClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete DOMImplementation global ref %x\n", 
-	    domImplementationClass));
-    return;
-  }
-  domImplementationClass = NULL;
-
-  env->DeleteGlobalRef(elementClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Element global ref %x\n", 
-	    elementClass));
-    return;
-  }
-  elementClass = NULL;
-
-  env->DeleteGlobalRef(entityClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Entity global ref %x\n", 
-	    entityClass));
-    return;
-  }
-  entityClass = NULL;
-
-  env->DeleteGlobalRef(entityReferenceClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete EntityReference global ref %x\n", 
-	    entityReferenceClass));
-    return;
-  }
-  entityReferenceClass = NULL;
-
-  env->DeleteGlobalRef(namedNodeMapClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete NamedNodeMap global ref %x\n", 
-	    namedNodeMapClass));
-    return;
-  }
-  namedNodeMapClass = NULL;
-
-  env->DeleteGlobalRef(nodeListClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete NodeList global ref %x\n", 
-	    nodeListClass));
-    return;
-  }
-  nodeListClass = NULL;
-
-  env->DeleteGlobalRef(nodeClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Node global ref %x\n", 
-	    nodeClass));
-    return;
-  }
-  nodeClass = NULL;
-
-  env->DeleteGlobalRef(notationClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Notation global ref %x\n", 
-	    notationClass));
-    return;
-  }
-  notationClass = NULL;
-
-  env->DeleteGlobalRef(processingInstructionClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete ProcessingInstruction global ref %x\n", 
-	    processingInstructionClass));
-    return;
-  }
-  processingInstructionClass = NULL;
-
-  env->DeleteGlobalRef(textClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete Text global ref %x\n", 
-	    textClass));
-    return;
-  }
-  textClass = NULL;
-
-  env->DeleteGlobalRef(domExceptionClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete DOM Exception global ref %x\n", 
-	    domExceptionClass));
-    return;
-  }
-  domExceptionClass = NULL;
-
-  env->DeleteGlobalRef(runtimeExceptionClass);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::Destroy: failed to delete DOM Exception global ref %x\n", 
-	    runtimeExceptionClass));
-    return;
-  }
-  runtimeExceptionClass = NULL;
-
-  TakeOutGarbage();
-  PR_DestroyLock(garbageLock);
-}
-
-jobject JavaDOMGlobals::CreateNodeSubtype(JNIEnv *env, 
-					  nsIDOMNode *node) 
-{
-  if (!node)
-    return NULL;
-
-  PRUint16 nodeType = 0;
-  (void) node->GetNodeType(&nodeType);
-
-  jclass clazz = nodeClass;
-  switch (nodeType) {
-  case nsIDOMNode::ATTRIBUTE_NODE:
-    clazz = attrClass;
-    break;
-
-  case nsIDOMNode::CDATA_SECTION_NODE:
-    clazz = cDataSectionClass;
-    break;
-
-  case nsIDOMNode::COMMENT_NODE:
-    clazz = commentClass;
-    break;
-
-  case nsIDOMNode::DOCUMENT_NODE:
-    clazz = documentClass;
-    break;
-
-  case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
-    clazz = documentFragmentClass;
-    break;
-
-  case nsIDOMNode::DOCUMENT_TYPE_NODE:
-    clazz = documentTypeClass;
-    break;
-
-  case nsIDOMNode::ELEMENT_NODE:
-    clazz = elementClass;
-    break;
-
-  case nsIDOMNode::ENTITY_NODE:
-    clazz = entityClass;
-    break;
-
-  case nsIDOMNode::ENTITY_REFERENCE_NODE:
-    clazz = entityReferenceClass;
-    break;
-
-  case nsIDOMNode::NOTATION_NODE:
-    clazz = notationClass;
-    break;
-
-  case nsIDOMNode::PROCESSING_INSTRUCTION_NODE:
-    clazz = processingInstructionClass;
-    break;
-
-  case nsIDOMNode::TEXT_NODE:
-    clazz = textClass;
-    break;
-  }
-
-  PR_LOG(log, PR_LOG_ERROR, 
-	 ("JavaDOMGlobals::CreateNodeSubtype: allocating Node of type %d, clazz=%x\n", 
-	  nodeType, clazz));
-  jobject jnode = env->AllocObject(clazz);
-  if (!jnode) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::CreateNodeSubtype: failed to allocate Node of type %d\n", 
-	    nodeType));
-    return NULL;
-  }
-
-  env->SetLongField(jnode, nodePtrFID, (jlong) node);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(log, PR_LOG_ERROR, 
-	   ("JavaDOMGlobals::CreateNodeSubtype: failed to set native ptr %x\n", 
-	    (jlong) node));
-    return NULL;
-  }
-  node->AddRef();
-
-  return jnode;
-}
-
-void JavaDOMGlobals::AddToGarbage(nsISupports* domObject)
-{
-  nsAutoLock lock(garbageLock);
-  jniDOMGarbage* elem = new jniDOMGarbage(domObject);
-  PR_INSERT_BEFORE(elem, &garbage);
-  PR_LOG(log, PR_LOG_DEBUG, 
-	 ("JavaDOMGlobals::AddToGarbage: Scheduling %x\n", domObject));
-}
-
-void JavaDOMGlobals::TakeOutGarbage()
-{
-  nsAutoLock lock(garbageLock);
-
-  PRUint32 count = 0;
-  nsISupports* domo = NULL;
-
-  PRCList* chain = NULL;
-  PRCList* elem = NULL;
-  for (chain = PR_LIST_HEAD(&garbage);
-       chain != &garbage; 
-       chain = PR_NEXT_LINK(chain)) {
-
-    delete elem;
-    elem = chain;
-    domo = ((jniDOMGarbage*) elem)->domObject;
-    PR_LOG(log, PR_LOG_DEBUG, 
-	   ("JavaDOMGlobals::TakeOutGarbage: Releasing %x\n", domo));
-    domo->Release();
-    domo = NULL;
-
-    count++;
-  }
-  delete elem;
-  PR_INIT_CLIST(&garbage);
-
-  if (count)
-    PR_LOG(log, PR_LOG_DEBUG, 
-	   ("JavaDOMGlobals::TakeOutGarbage: Released %d objects\n", count));
-}
-
-// caller must return from JNI immediately after calling this function
-void JavaDOMGlobals::ThrowException(JNIEnv *env,
-                                    const char * message,
-                                    nsresult rv,
-                                    ExceptionType exceptionType) {
-
-  jthrowable newException = NULL;
-
-  if (exceptionType == EXCEPTION_DOM) {
-    PR_LOG(log, PR_LOG_ERROR, 
-           ("JavaDOMGlobals::ThrowException: (%x) %s: %s\n", 
-            NS_ERROR_GET_CODE(rv), 
-            message ? message : "", 
-            DOM_EXCEPTION_MESSAGE[NS_ERROR_GET_CODE(rv)]));
-
-    jstring jmessage = 
-      env->NewStringUTF(DOM_EXCEPTION_MESSAGE[NS_ERROR_GET_CODE(rv)]);
-
-    newException = 
-      (jthrowable)env->NewObject(domExceptionClass, 
-                                 domExceptionInitMID,
-                                 NS_ERROR_GET_CODE(rv),
-                                 jmessage);
-  } else {
-    char buffer[256];
-    const char* msg = message;
-    if (rv != NS_OK) {
-      sprintf(buffer, 
-              "(%x.%x) %s",
-              NS_ERROR_GET_MODULE(rv),
-              NS_ERROR_GET_CODE(rv),
-              message ? message : "");
-      msg = buffer;
-    }
-
-    PR_LOG(log, PR_LOG_ERROR, 
-           ("JavaDOMGlobals::ThrowException: %s\n", msg));
-
-    jstring jmessage = env->NewStringUTF(msg);
-
-    newException = 
-      (jthrowable)env->NewObject(runtimeExceptionClass, 
-                                 runtimeExceptionInitMID,
-                                 jmessage);
-
-  }
-
-  if (newException != NULL) {
-    env->Throw(newException);
-  } 
-
-  // an exception is thrown in any case
-}
-
-nsString* JavaDOMGlobals::GetUnicode(JNIEnv *env,
-				     jstring jstr)
-{
-  jboolean iscopy = JNI_FALSE;
-  const jchar* name = env->GetStringChars(jstr, &iscopy);
-  if (!name) {
-    ThrowException(env, "GetStringChars failed");
-    return NULL;
-  }
-  nsString* ustr = new nsString((PRUnichar*)name, 
-				env->GetStringLength(jstr));
-  env->ReleaseStringChars(jstr, name);
-  return ustr;
-}

mozilla/java/dom/jni/javaDOMGlobals.h

@@ -1,111 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#ifndef __JavaDOMGlobals_h__
-#define __JavaDOMGlobals_h__
-
-#include "jni.h"
-#include "prclist.h"
-#include "nsError.h"
-#include "nsString.h"
-
-// workaround for bug 30927
-#ifdef ERROR
-#undef ERROR
-#endif
-
-class nsISupports;
-class nsIDOMNode;
-struct PRLogModuleInfo;
-struct PRLock;
-
-class JavaDOMGlobals {
-
- public:
-  static jclass attrClass;
-  static jclass cDataSectionClass;
-  static jclass commentClass;
-  static jclass documentClass;
-  static jclass documentFragmentClass;
-  static jclass documentTypeClass;
-  static jclass domImplementationClass;
-  static jclass elementClass;
-  static jclass entityClass;
-  static jclass entityReferenceClass;
-  static jclass namedNodeMapClass;
-  static jclass nodeClass;
-  static jclass nodeListClass;
-  static jclass notationClass;
-  static jclass processingInstructionClass;
-  static jclass textClass;
-
-  static jfieldID nodePtrFID;
-  static jfieldID nodeListPtrFID;
-  static jfieldID domImplementationPtrFID;
-  static jfieldID namedNodeMapPtrFID;
-
-  static jfieldID nodeTypeAttributeFID;
-  static jfieldID nodeTypeCDataSectionFID;
-  static jfieldID nodeTypeCommentFID;
-  static jfieldID nodeTypeDocumentFragmentFID;
-  static jfieldID nodeTypeDocumentFID;
-  static jfieldID nodeTypeDocumentTypeFID;
-  static jfieldID nodeTypeElementFID;
-  static jfieldID nodeTypeEntityFID;
-  static jfieldID nodeTypeEntityReferenceFID;
-  static jfieldID nodeTypeNotationFID;
-  static jfieldID nodeTypeProcessingInstructionFID;
-  static jfieldID nodeTypeTextFID;
-
-  static jclass domExceptionClass;
-  static jmethodID domExceptionInitMID;
-  static jclass runtimeExceptionClass;
-  static jmethodID runtimeExceptionInitMID;
-
-  static const char* const DOM_EXCEPTION_MESSAGE[];
-
-  typedef enum ExceptionType { EXCEPTION_RUNTIME, 
-			       EXCEPTION_DOM } ExceptionType;
-  
-  static PRLogModuleInfo* log;
-  static PRCList garbage;
-  static PRLock* garbageLock;
-
-  static PRInt32 javaMaxInt;
-
-  static void Initialize(JNIEnv *env);
-  static void Destroy(JNIEnv *env);
-  static jobject CreateNodeSubtype(JNIEnv *env, 
-				   nsIDOMNode *node);
-
-  static void AddToGarbage(nsISupports* domObject);
-  static void TakeOutGarbage();
-
-  static void ThrowException(JNIEnv *env,
-                             const char * message = NULL,
-                             nsresult rv = NS_OK,
-                             ExceptionType exceptionType = EXCEPTION_RUNTIME);
-
-  static nsString* GetUnicode(JNIEnv *env,
-			      jstring str);
-};
-  
-#endif /* __JavaDOMGlobals_h__ */

mozilla/java/dom/jni/makefile.win

@@ -1,128 +0,0 @@
-#!nmake
-#
-# 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 Sun Microsystems,
-# Inc. Portions created by Sun are
-# Copyright (C) 1999 Sun Microsystems, Inc. All
-# Rights Reserved.
-#
-# Contributor(s): 
-
-DEPTH=..\..\..
-IGNORE_MANIFEST=1
-
-DEFINES=-D_IMPL_NS_WEB -DWIN32_LEAN_AND_MEAN
-MODULE=javadomjni
-
-CPPSRCS= \
-	javaDOMGlobals.cpp \
-	javaDOMEventsGlobals.cpp \
-	nativeDOMProxyListener.cpp \
-	org_mozilla_dom_DOMAccessor.cpp \
-	org_mozilla_dom_AttrImpl.cpp \
-	org_mozilla_dom_CharacterDataImpl.cpp \
-	org_mozilla_dom_DocumentImpl.cpp \
-	org_mozilla_dom_DocumentTypeImpl.cpp \
-	org_mozilla_dom_DOMImplementationImpl.cpp \
-	org_mozilla_dom_ElementImpl.cpp \
-	org_mozilla_dom_EntityImpl.cpp \
-	org_mozilla_dom_NamedNodeMapImpl.cpp \
-	org_mozilla_dom_NodeImpl.cpp \
-	org_mozilla_dom_NodeListImpl.cpp \
-	org_mozilla_dom_NotationImpl.cpp \
-	org_mozilla_dom_ProcessingInstructionImpl.cpp \
-	org_mozilla_dom_TextImpl.cpp \
-	org_mozilla_dom_events_EventImpl.cpp \
-	org_mozilla_dom_events_MouseEventImpl.cpp \
-	org_mozilla_dom_events_UIEventImpl.cpp \
- $(NULL)
-
-CPP_OBJS= \
-	.\$(OBJDIR)\javaDOMGlobals.obj \
-	.\$(OBJDIR)\javaDOMEventsGlobals.obj \
-	.\$(OBJDIR)\nativeDOMProxyListener.obj \
-	.\$(OBJDIR)\org_mozilla_dom_DOMAccessor.obj \
-	.\$(OBJDIR)\org_mozilla_dom_AttrImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_CharacterDataImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_DocumentImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_DocumentTypeImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_DOMImplementationImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_ElementImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_EntityImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_NamedNodeMapImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_NodeImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_NodeListImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_NotationImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_ProcessingInstructionImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_TextImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_events_EventImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_events_UIEventImpl.obj \
-	.\$(OBJDIR)\org_mozilla_dom_events_MouseEventImpl.obj \
-$(NULL)
-
-JAVA_CLS= \
-	org.mozilla.dom.DOMAccessor \
-	org.mozilla.dom.AttrImpl \
-	org.mozilla.dom.CharacterDataImpl \
-	org.mozilla.dom.DocumentImpl \
-	org.mozilla.dom.DocumentTypeImpl \
-	org.mozilla.dom.DOMImplementationImpl \
-	org.mozilla.dom.ElementImpl \
-	org.mozilla.dom.EntityImpl \
-	org.mozilla.dom.NamedNodeMapImpl \
-	org.mozilla.dom.NodeImpl \
-	org.mozilla.dom.NodeListImpl \
-	org.mozilla.dom.NotationImpl \
-	org.mozilla.dom.ProcessingInstructionImpl \
-	org.mozilla.dom.TextImpl \
-	org.mozilla.dom.events.EventImpl \
-	org.mozilla.dom.events.MouseEventImpl \
-	org.mozilla.dom.events.UIEventImpl \
- $(NULL)
-
-
-LINCS=
-
-MAKE_OBJ_TYPE = DLL
-DLLNAME = javadomjni
-DLL=.\$(OBJDIR)\$(DLLNAME).dll
-LIBRARY_NAME=javadomimpl
-
-LCFLAGS = \
-	$(LCFLAGS) \
-	$(DEFINES) \
- $(NULL)
-
-# These are the libraries we need to link with to create the dll
-LLIBS= \
- $(DIST)\lib\xpcom.lib \
- $(LIBNSPR)
-
-include <$(DEPTH)\config\config.mak>
-include <$(DEPTH)\config\rules.mak>
-
-JAVAH_PROG=$(JDKHOME)\bin\javah
-JAVAH_FLAGS=-jni -classpath $(CLASSPATH);$(JAVA_DESTPATH)
-
-export::
-	$(JAVAH_PROG) $(JAVAH_FLAGS) $(JAVA_CLS)
-
-install:: $(DLL)
-	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin
-	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
-
-clobber::
-	rm -f $(DIST)\bin\$(DLLNAME).dll
-	rm -f $(DIST)\lib\$(DLLNAME).lib
-	rm -f org_*.h

mozilla/java/dom/jni/nativeDOMProxyListener.cpp

@@ -1,130 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include<stdio.h>
-#include"prlog.h"
-#include"nativeDOMProxyListener.h"
-#include"nsIDOMNode.h"
-#include"nsIDOMEventTarget.h"
-#include"nsIDOMEventListener.h"
-#include"javaDOMEventsGlobals.h"
-
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-static NS_DEFINE_IID(kIDOMEventListener, NS_IDOMEVENTLISTENER_IID);
-
-NativeDOMProxyListener::NativeDOMProxyListener(JNIEnv *env, jobject jlistener) 
-{  
-    mRefCnt = 0;  
-    listener = env->NewGlobalRef(jlistener);
-
-    if (env->GetJavaVM(&vm) != 0) 
-        PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-            ("NativeDOMProxyListener: Can't objant jvm\n"));
-}  
-
-
-//should be called oly from NativeDOMProxyListener::Release
-NativeDOMProxyListener::~NativeDOMProxyListener() 
-{
-    JNIEnv *env;
-
-    if (vm->AttachCurrentThread( &env, NULL) != 0) 
-        PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-            ("NativeDOMProxyListener: Can't attach current thread to JVM\n"));
-
-    env->DeleteGlobalRef(listener);
-    if (env->ExceptionOccurred()) {
-        PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-            ("NativeDOMProxyListener::Destroy: failed to delete EventListener global ref %x\n", 
-             listener));
-        return;
-    }
-}
-
-nsresult NativeDOMProxyListener::HandleEvent(nsIDOMEvent* aEvent) 
-{
-    jobject jevent;
-    JNIEnv *env;
-
-    if (vm->AttachCurrentThread( &env, NULL) != 0) {
-        PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-            ("NativeDOMProxyListener:HandleEvent Can't attach current thread to JVM\n"));
-        return NS_ERROR_FAILURE;
-    }
-
-    jevent = JavaDOMEventsGlobals::CreateEventSubtype(env, aEvent);
-
-    if (!jevent) {
-        PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING,
-            ("NativeDOMProxyListener::HandleEvent Can't create java event object"));
-        return NS_ERROR_FAILURE;
-    }
-
-    env->CallVoidMethod(listener,
-                        JavaDOMEventsGlobals::eventListenerHandleEventMID,
-                        jevent);    
-
-    if (env->ExceptionOccurred()) {
-        PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-            ("NativeDOMProxyListener::HandleEvent: failed to call EventListener %x\n", 
-             listener));
-        return NS_ERROR_FAILURE;
-    }
-
-    return NS_OK;
-}
-
-nsresult NativeDOMProxyListener::QueryInterface(const nsIID &aIID, void **aResult)
-{
-    if (aResult == NULL) {  
-        return NS_ERROR_NULL_POINTER;  
-    }  
-
-    // Always NULL result, in case of failure  
-    *aResult = NULL;  
-
-    if (aIID.Equals(kISupportsIID)) {  
-        *aResult = (void *) this;  
-    } else if (aIID.Equals(kIDOMEventListener)) {  
-        *aResult = (void *) this;  
-    }  
-
-    if (aResult != NULL) {  
-        return NS_ERROR_NO_INTERFACE;  
-    }  
-
-    AddRef();  
-    return NS_OK;  
-}
-
-nsrefcnt NativeDOMProxyListener::AddRef()
-{
-    return mRefCnt++;
-}
-
-nsrefcnt NativeDOMProxyListener::Release()
-{
-    if (--mRefCnt == 0) {  
-        delete this;  
-        return 0; // Don't access mRefCnt after deleting! 
-    }      
-    return mRefCnt;
-}

mozilla/java/dom/jni/nativeDOMProxyListener.h

@@ -1,29 +0,0 @@
-#ifndef __JAVA_DOM_NATIVE_PROXY_LISTENER__
-#define __JAVA_DOM_NATIVE_PROXY_LISTENER__
-
-#include"nsIDOMEventListener.h"
-#include"jni.h"
-
-class NativeDOMProxyListener: public nsIDOMEventListener{
-
-    private:
-        JavaVM *vm;
-        jobject listener;
-        nsrefcnt mRefCnt;  
-
-	//to be used only by Release()
-	virtual ~NativeDOMProxyListener();
-    public:
-
-	NativeDOMProxyListener(JNIEnv *env, jobject jlistener);
-
-	virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
-
-	NS_IMETHOD QueryInterface(const nsIID &aIID,  void **aResult);  
-	NS_IMETHOD_(nsrefcnt) AddRef(void);  
-	NS_IMETHOD_(nsrefcnt) Release(void);  
-
-};
-
-#endif
-

mozilla/java/dom/jni/org_mozilla_dom_AttrImpl.cpp

@@ -1,177 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMAttr.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_AttrImpl.h"
-
-/*
- * Class:     org_mozilla_dom_AttrImpl
- * Method:    getName
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_AttrImpl_getName
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMAttr* attr = (nsIDOMAttr*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!attr) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getName: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString name;
-  nsresult rv = attr->GetName(name);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getName: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jname = env->NewString(name.GetUnicode(), name.Length());
-  if (!jname) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getName: NewString failed\n"));
-  }
-
-  return jname;
-}
-
-/*
- * Class:     org_mozilla_dom_AttrImpl
- * Method:    getSpecified
- * Signature: ()Z
- */
-JNIEXPORT jboolean JNICALL Java_org_mozilla_dom_AttrImpl_getSpecified
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMAttr* attr = (nsIDOMAttr*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!attr) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getSpecified: NULL pointer\n"));
-    return JNI_FALSE;
-  }
-
-  PRBool specified = PR_FALSE;
-  nsresult rv = attr->GetSpecified(&specified);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getSpecified: failed (%x)\n", rv));
-    return JNI_FALSE;
-  }
-
-  return (specified == PR_TRUE) ? JNI_TRUE : JNI_FALSE;
-}
-
-/*
- * Class:     org_mozilla_dom_AttrImpl
- * Method:    getValue
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_AttrImpl_getValue
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMAttr* attr = (nsIDOMAttr*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!attr) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getValue: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString value;
-  nsresult rv = attr->GetValue(value);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getValue: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jval = env->NewString(value.GetUnicode(), value.Length());
-  if (!jval) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getValue: NewString failed\n"));
-  }
-
-  return jval;
-}
-
-/*
- * Class:     org_mozilla_dom_AttrImpl
- * Method:    setValue
- * Signature: (Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_AttrImpl_setValue
-  (JNIEnv *env, jobject jthis, jstring jval)
-{
-  nsIDOMAttr* attr = (nsIDOMAttr*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!attr || !jval) {
-    JavaDOMGlobals::ThrowException(env,
-      "Attr.setValue: NULL pointer\n");
-    return;
-  }
-
-  
-  nsString* cstr = JavaDOMGlobals::GetUnicode(env, jval);
-  if (!cstr)
-    return;
-
-  nsresult rv = attr->SetValue(*cstr);
-  nsString::Recycle(cstr);
-
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.setValue: failed (%x)\n", rv));
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_AttrImpl
- * Method:    getOwnerElement
- * Signature: ()Lorg/w3c/dom/Element;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_AttrImpl_getOwnerElement
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMAttr* attr = (nsIDOMAttr*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!attr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Attr.setValue: NULL pointer\n");
-    return NULL;
-  }
-
-  nsIDOMElement* aOwnerElement = nsnull;
-  nsresult rv = attr->GetOwnerElement(&aOwnerElement);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Attr.getOwnerElement: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, (nsIDOMNode*)aOwnerElement);
-}
-

mozilla/java/dom/jni/org_mozilla_dom_CharacterDataImpl.cpp

@@ -1,323 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMCharacterData.h"
-#include "nsDOMError.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_CharacterDataImpl.h"
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    appendData
- * Signature: (Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_CharacterDataImpl_appendData
-  (JNIEnv *env, jobject jthis, jstring jvalue)
-{
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data || !jvalue) {
-    JavaDOMGlobals::ThrowException(env, 
-      "CharacterData.appendData: NULL pointer");
-    return;
-  }
-  
-  nsString* value = JavaDOMGlobals::GetUnicode(env, jvalue);
-  if (!value)
-    return;
-
-  nsresult rv = data->AppendData(*value);
-  nsString::Recycle(value);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.appendData: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    deleteData
- * Signature: (II)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_CharacterDataImpl_deleteData
-  (JNIEnv *env, jobject jthis, jint offset, jint count)
-{
-  if (offset < 0 || offset > JavaDOMGlobals::javaMaxInt || 
-      count < 0 || count > JavaDOMGlobals::javaMaxInt) {
-    JavaDOMGlobals::ThrowException(env, "CharacterData.deleteData: failed",
-                 NS_ERROR_DOM_INDEX_SIZE_ERR,
-                 JavaDOMGlobals::EXCEPTION_DOM);
-    return;
-  }
-
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.deleteData: NULL pointer");
-    return;
-  }
-  
-  nsresult rv = data->DeleteData((PRUint32) offset, (PRUint32) count);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_INDEX_SIZE_ERR ||
-         rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "CharacterData.deleteData: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    getData
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_CharacterDataImpl_getData
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.getData: NULL pointer");
-    return NULL;
-  }
-  
-  nsString ret;
-  nsresult rv = data->GetData(ret);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_DOMSTRING_SIZE_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "CharacterData.getData: failed", rv, exceptionType);
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.getData: NewString failed");
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    getLength
- * Signature: ()I
- */
-JNIEXPORT jint JNICALL Java_org_mozilla_dom_CharacterDataImpl_getLength
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.getLength: NULL pointer");
-    return 0;
-  }
-  
-  PRUint32 len = 0;
-  nsresult rv = data->GetLength(&len);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.getLength: failed", rv);
-    return 0;
-  }
-
-  return (jint) len;
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    insertData
- * Signature: (ILjava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_CharacterDataImpl_insertData
-  (JNIEnv *env, jobject jthis, jint offset, jstring jvalue)
-{
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data || !jvalue) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.insertData: NULL pointer");
-    return;
-  }
-  
-  nsString* value = JavaDOMGlobals::GetUnicode(env, jvalue);
-  if (!value)
-    return;
-
-  nsresult rv = data->InsertData((PRUint32) offset, *value);
-  nsString::Recycle(value);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_INDEX_SIZE_ERR ||
-         rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "CharacterData.insertData: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    replaceData
- * Signature: (IILjava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_CharacterDataImpl_replaceData
-  (JNIEnv *env, jobject jthis, jint offset, jint count, jstring jvalue)
-{
-  if (offset < 0 || offset > JavaDOMGlobals::javaMaxInt || 
-      count < 0 || count > JavaDOMGlobals::javaMaxInt) {
-    JavaDOMGlobals::ThrowException(env, "CharacterData.replaceData: failed",
-                 NS_ERROR_DOM_INDEX_SIZE_ERR,
-                 JavaDOMGlobals::EXCEPTION_DOM);
-    return;
-  }
-
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data || !jvalue) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.replaceData: NULL pointer");
-    return;
-  }
-  
-  nsString* value = JavaDOMGlobals::GetUnicode(env, jvalue);
-  if (!value)
-    return;
-
-  nsresult rv = data->ReplaceData((PRUint32) offset, (PRUint32) count, *value);
-  nsString::Recycle(value);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_INDEX_SIZE_ERR ||
-         rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "CharacterData.replaceData: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    setData
- * Signature: (Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_CharacterDataImpl_setData
-  (JNIEnv *env, jobject jthis, jstring jvalue)
-{
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data || !jvalue) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.setData: NULL pointer");
-    return;
-  }
-  
-  nsString* value = JavaDOMGlobals::GetUnicode(env, jvalue);
-  if (!value)
-    return;
-
-  nsresult rv = data->SetData(*value);
-  nsString::Recycle(value);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "CharacterData.setData: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_CharacterDataImpl
- * Method:    substringData
- * Signature: (II)Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_CharacterDataImpl_substringData
-  (JNIEnv *env, jobject jthis, jint offset, jint count)
-{
-  if (offset < 0 || offset > JavaDOMGlobals::javaMaxInt || 
-      count < 0 || count > JavaDOMGlobals::javaMaxInt) {
-    JavaDOMGlobals::ThrowException(env, "CharacterData.substringData: failed",
-                 NS_ERROR_DOM_INDEX_SIZE_ERR,
-                 JavaDOMGlobals::EXCEPTION_DOM);
-    return NULL;
-  }
-
-  nsIDOMCharacterData* data = (nsIDOMCharacterData*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!data) {
-    JavaDOMGlobals::ThrowException(env,  
-      "CharacterData.substringData: NULL pointer");
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = data->SubstringData((PRUint32) offset, (PRUint32) count, ret);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_INDEX_SIZE_ERR ||
-         rv == NS_ERROR_DOM_DOMSTRING_SIZE_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "CharacterData.substringData: failed", rv, exceptionType);
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env, 
-      "CharacterData.substringData: NewString failed");
-  }
-
-  return jret;
-}

mozilla/java/dom/jni/org_mozilla_dom_DOMAccessor.cpp

@@ -1,118 +0,0 @@
-
-#include "prlog.h"
-#include "javaDOMGlobals.h"
-#include "nsIDocumentLoader.h"
-#include "nsIDocumentLoaderObserver.h"
-#include "nsIServiceManager.h"
-#include "nsCURILoader.h"
-
-#include "nsIJavaDOM.h"
-#include "org_mozilla_dom_DOMAccessor.h"
-
-static NS_DEFINE_IID(kDocLoaderServiceCID, NS_DOCUMENTLOADER_SERVICE_CID);
-static NS_DEFINE_IID(kJavaDOMCID, NS_JAVADOM_CID);
-
-/*
- * Class:     org_mozilla_dom_DOMAccessor
- * Method:    register
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_DOMAccessor_register
-  (JNIEnv *env, jclass jthis)
-{
-  if (!JavaDOMGlobals::log) {
-    JavaDOMGlobals::Initialize(env);
-  }
-  nsresult rv = NS_OK; 
-  NS_WITH_SERVICE(nsIDocumentLoader, docLoaderService, kDocLoaderServiceCID, &rv);
-  if (NS_FAILED(rv) || !docLoaderService) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DOMAccessor::register: GetService(JavaDOM) failed: %x\n", 
-	    rv));
-  } else {
-    NS_WITH_SERVICE(nsIDocumentLoaderObserver, javaDOM, kJavaDOMCID, &rv);
-    if (NS_FAILED(rv) || !javaDOM) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	     ("DOMAccessor::register: GetService(JavaDOM) failed: %x\n", 
-	      rv));
-    } else {
-      rv = docLoaderService->AddObserver((nsIDocumentLoaderObserver*)javaDOM);
-      if (NS_FAILED(rv)) {
-	PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	       ("DOMAccessor::register: AddObserver(JavaDOM) failed x\n", 
-		rv));
-      }
-    }
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_DOMAccessor
- * Method:    unregister
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_DOMAccessor_unregister
-  (JNIEnv *, jclass jthis)
-{
-  PR_LOG(JavaDOMGlobals::log, PR_LOG_DEBUG, 
-	 ("DOMAccessor::unregister: unregistering %x\n", jthis));
-
-  nsresult rv = NS_OK;
-  NS_WITH_SERVICE(nsIDocumentLoader, docLoaderService, kDocLoaderServiceCID, &rv);
-  if (NS_FAILED(rv) || !docLoaderService) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DOMAccessor::unregister: GetService(DocLoaderService) failed %x\n", 
-	    rv));
-  } else {
-    NS_WITH_SERVICE(nsIDocumentLoaderObserver, javaDOM, kJavaDOMCID, &rv);
-    if (NS_FAILED(rv) || !javaDOM) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	     ("DOMAccessor::unregister: GetService(JavaDOM) failed %x\n", 
-	      rv));
-    } else {
-      rv = docLoaderService->RemoveObserver((nsIDocumentLoaderObserver*)javaDOM);
-      if (NS_FAILED(rv)) {
-	PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	       ("DOMAccessor::unregister: RemoveObserver(JavaDOM) failed x\n", 
-		rv));
-      }
-    }
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_DOMAccessor
- * Method:    createElement
- * Signature: (J)Lorg/w3c/dom/Element;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DOMAccessor_getNodeByHandle
-  (JNIEnv *env, jclass jthis, jlong p)
-{ 
-  if (!JavaDOMGlobals::log) {
-    JavaDOMGlobals::Initialize(env);
-  }
-  nsIDOMNode *node = (nsIDOMNode*)p;
-  return JavaDOMGlobals::CreateNodeSubtype(env, node);
-}
-
-/*
- * Class:     org_mozilla_dom_DOMAccessor
- * Method:    doGC
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_DOMAccessor_doGC
-  (JNIEnv *, jclass)
-{
-  JavaDOMGlobals::TakeOutGarbage();
-}
-
-JNIEXPORT void JNICALL Java_org_mozilla_dom_DOMAccessor_initialize
-(JNIEnv *env, jclass)
-{
-  if (!JavaDOMGlobals::log) {
-    JavaDOMGlobals::Initialize(env);
-  }
-  
-}
-
-

mozilla/java/dom/jni/org_mozilla_dom_DOMImplementationImpl.cpp

@@ -1,290 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMDOMImplementation.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_DOMImplementationImpl.h"
-#include "nsDOMError.h"
-
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-
-/*
- * Class:     org_mozilla_dom_DOMImplementationImpl
- * Method:    XPCOM_equals
- * Signature: (Ljava/lang/Object;)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_mozilla_dom_DOMImplementationImpl_XPCOM_1equals
-  (JNIEnv *env, jobject jthis, jobject jarg)
-{
-  jboolean b_retFlag = JNI_FALSE;
-
-  nsIDOMDOMImplementation* p_this = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jthis, JavaDOMGlobals::domImplementationPtrFID);
-  if (!p_this) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DOMImplementation.equals: NULL pointer\n"));
-    return b_retFlag;
-  }
-
-  nsIDOMDOMImplementation* p_arg = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jarg, JavaDOMGlobals::domImplementationPtrFID);
-  if (!p_arg) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DOMImplementation.equals: NULL arg pointer\n"));
-    return b_retFlag;
-  }
-
-  nsISupports* thisSupports = nsnull;
-  nsISupports* argSupports = nsnull;
-
-  nsresult rvThis = 
-    p_this->QueryInterface(kISupportsIID, (void**)(&thisSupports));
-  if (NS_FAILED(rvThis) || !thisSupports) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DOMImplementation.equals: this->QueryInterface failed (%x)\n", 
-	    rvThis));
-    return b_retFlag; 	
-  }
-
-  nsresult rvArg =
-    p_arg->QueryInterface(kISupportsIID, (void**)(&argSupports));
-  if (NS_FAILED(rvArg) || !argSupports) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DOMImplementation.equals: arg->QueryInterface failed (%x)\n", 
-	    rvArg));
-    thisSupports->Release();
-    return b_retFlag;
-  }
-
-  if (thisSupports == argSupports)
-    b_retFlag = JNI_TRUE;
-  
-  thisSupports->Release();
-  argSupports->Release();
-
-  return b_retFlag;
-}
-
-/*
- * Class:     org_mozilla_dom_DOMImplementationImpl
- * Method:    XPCOM_hashCode
- * Signature: ()I
- */
-JNIEXPORT jint JNICALL Java_org_mozilla_dom_DOMImplementationImpl_XPCOM_1hashCode
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDOMImplementation* p_this = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jthis, JavaDOMGlobals::domImplementationPtrFID);
-  if (!p_this) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DOMImplementation.hashCode: NULL pointer\n"));
-    return (jint) 0;
-  }
-
-  nsISupports* thisSupports = nsnull;
-  nsresult rvThis = 
-    p_this->QueryInterface(kISupportsIID, (void**)(&thisSupports));
-  if (NS_FAILED(rvThis) || !thisSupports) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DOMImplementation.hashCode: QueryInterface failed (%x)\n", 
-	    rvThis));
-    return (jint) 0;
-  }
-
-  thisSupports->Release();
-  return (jint) thisSupports;
-}
-
-/*
- * Class:     org_mozilla_dom_DOMImplementationImpl
- * Method:    finalize
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_DOMImplementationImpl_finalize
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDOMImplementation* dom = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jthis, JavaDOMGlobals::domImplementationPtrFID);
-  if (!dom) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DOMImplementation.finalize: NULL pointer\n"));
-    return;
-  }
-
-  JavaDOMGlobals::AddToGarbage(dom);
-}
-
-/*
- * Class:     org_mozilla_dom_DOMImplementationImpl
- * Method:    hasFeature
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_mozilla_dom_DOMImplementationImpl_hasFeature
-  (JNIEnv *env, jobject jthis, jstring jfeature, jstring jversion)
-{
-  nsIDOMDOMImplementation* dom = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jthis, JavaDOMGlobals::domImplementationPtrFID);
-  if (!dom || !jfeature) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DOMImplementation.hasFeature: NULL pointer\n"));
-    return JNI_FALSE;
-  }
-
-  nsString* feature = JavaDOMGlobals::GetUnicode(env, jfeature);
-  if (!feature)
-      return JNI_FALSE;
-
-  nsString* version;
-  if (jversion) {
-      version = JavaDOMGlobals::GetUnicode(env, jversion);
-      if (!version) {
-	  nsString::Recycle(feature);
-	  return JNI_FALSE;
-      }
-  } else {
-      version = new nsString();
-  }
-
-  PRBool ret = PR_FALSE;
-  nsresult rv = dom->HasFeature(*feature, *version, &ret);
-  nsString::Recycle(feature);
-  nsString::Recycle(version);
-
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DOMImplementation.hasFeature: failed (%x)\n", rv));
-  }
-
-  return ret == PR_TRUE ? JNI_TRUE : JNI_FALSE;
-}
-
-/*
- * Class:     org_mozilla_dom_DOMImplementationImpl
- * Method:    createDocumentType
- * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/DocumentType;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DOMImplementationImpl_createDocumentType
-  (JNIEnv *env, jobject jthis, jstring jqualifiedName, jstring jpublicID, jstring jsystemID)
-{
-  nsIDOMDOMImplementation* dom = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jthis, JavaDOMGlobals::domImplementationPtrFID);
-  if (!dom || !jqualifiedName || !jpublicID || !jsystemID) {
-    JavaDOMGlobals::ThrowException(env,
-	"DOMImplementation.createDocumentType: NULL pointer");
-    return NULL;
-  }
-
-  nsString* qualifiedName = JavaDOMGlobals::GetUnicode(env, jqualifiedName);
-  if (!qualifiedName)
-      return NULL;
-
-  nsString* publicID = JavaDOMGlobals::GetUnicode(env, jpublicID);
-  if (!publicID) {
-      nsString::Recycle(qualifiedName);
-      return NULL;
-  }
-
-  nsString* systemID = JavaDOMGlobals::GetUnicode(env, jsystemID);
-  if (!systemID) {
-      nsString::Recycle(qualifiedName);
-      nsString::Recycle(publicID);
-      return NULL;
-  }
-
-  nsIDOMDocumentType* docType = nsnull;
-  nsresult rv = dom->CreateDocumentType(*qualifiedName, *publicID, *systemID, &docType);
-  nsString::Recycle(qualifiedName);
-  nsString::Recycle(publicID);
-  nsString::Recycle(systemID);
-
-  if (NS_FAILED(rv)) {
-      JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-      if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-	  (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR ||
-	   rv == NS_ERROR_DOM_NAMESPACE_ERR)) {
-	  exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-      }
-      JavaDOMGlobals::ThrowException(env,
-	  "DOMImplementation.createDocumentType: failed", rv, exceptionType);
-      return NULL;
-  }
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, (nsIDOMNode*)docType);
-}
-
-/*
- * Class:     org_mozilla_dom_DOMImplementationImpl
- * Method:    createDocument
- * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/w3c/dom/DocumentType;)Lorg/w3c/dom/Document;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DOMImplementationImpl_createDocument
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jqualifiedName, jobject jdoctype)
-{
-  nsIDOMDOMImplementation* dom = (nsIDOMDOMImplementation*) 
-    env->GetLongField(jthis, JavaDOMGlobals::domImplementationPtrFID);
-  if (!dom || !jnamespaceURI || !jqualifiedName) {
-    JavaDOMGlobals::ThrowException(env,
-	"DOMImplementation.createDocument: NULL pointer");
-    return NULL;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return NULL;
-
-  nsString* qualifiedName = JavaDOMGlobals::GetUnicode(env, jqualifiedName);
-  if (!qualifiedName) {
-      nsString::Recycle(namespaceURI);
-      return NULL;
-  }
-
-  nsIDOMDocumentType* docType = nsnull;
-  if (jdoctype) {
-      docType = (nsIDOMDocumentType*)
-	env->GetLongField(jdoctype, JavaDOMGlobals::nodeListPtrFID);
-      if (!docType) {
-	JavaDOMGlobals::ThrowException(env,
-	    "DOMImplementation.createDocument: NULL arg pointer");
-	return NULL;
-      }
-  }
-
-  nsIDOMDocument* doc = nsnull;
-  nsresult rv = dom->CreateDocument(*namespaceURI, *qualifiedName, docType, &doc);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(qualifiedName);
-
-  if (NS_FAILED(rv)) {
-      JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-      if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-	  (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR ||
-	   rv == NS_ERROR_DOM_NAMESPACE_ERR ||
-	   rv == NS_ERROR_DOM_WRONG_DOCUMENT_ERR)) {
-	  exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-      }
-      JavaDOMGlobals::ThrowException(env,
-	  "DOMImplementation.createDocument: failed", rv, exceptionType);
-      return NULL;
-  }
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, (nsIDOMNode*)doc);    
-}

mozilla/java/dom/jni/org_mozilla_dom_DocumentImpl.cpp

@@ -1,759 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMDocument.h"
-#include "nsIDOMAttr.h"
-#include "nsIDOMComment.h"
-#include "nsIDOMElement.h"
-#include "nsIDOMDocumentType.h"
-#include "nsIDOMDocumentFragment.h"
-#include "nsIDOMNodeList.h"
-#include "nsIDOMCDATASection.h"
-#include "nsIDOMEntityReference.h"
-#include "nsIDOMDOMImplementation.h"
-#include "nsIDOMProcessingInstruction.h"
-#include "nsIDOMDocumentEvent.h"
-#include "nsDOMError.h"
-#include "javaDOMGlobals.h"
-#include "javaDOMEventsGlobals.h"
-#include "org_mozilla_dom_DocumentImpl.h"
-
-static NS_DEFINE_IID(kIDOMDocumentEventIID, NS_IDOMDOCUMENTEVENT_IID);
-
-// undefine macros from WINBASE.H
-#ifdef CreateEvent
-#undef CreateEvent
-#endif
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createAttribute
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Attr;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createAttribute
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jname) {
-    JavaDOMGlobals::ThrowException(env, 
-      "Document.createAttribute: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* ret = nsnull;
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-    return NULL;
-
-  nsresult rv = doc->CreateAttribute(*name, &ret);  
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createAttribute: failed", rv, exceptionType);
-
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::attrClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createAttribute: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createAttribute: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createCDATASection
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/CDATASection;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createCDATASection
-  (JNIEnv *env, jobject jthis, jstring jdata)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jdata) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createCDATASection: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMCDATASection* ret = nsnull;
-  nsString* data = JavaDOMGlobals::GetUnicode(env, jdata);
-  if (!data)
-    return NULL;
-
-  nsresult rv = doc->CreateCDATASection(*data, &ret);
-  nsString::Recycle(data);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_NOT_SUPPORTED_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createCDATASection: failed", rv, exceptionType);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::cDataSectionClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createCDATASection: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createCDATASection: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createComment
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Comment;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createComment
-  (JNIEnv *env, jobject jthis, jstring jdata)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jdata) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createComment: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMComment* ret = nsnull;
-  nsString* data = JavaDOMGlobals::GetUnicode(env, jdata);
-  if (!data)
-    return NULL;
-
-  nsresult rv = doc->CreateComment(*data, &ret);  
-  nsString::Recycle(data);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createComment: failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::commentClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createComment: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createComment: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createDocumentFragment
- * Signature: ()Lorg/w3c/dom/DocumentFragment;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createDocumentFragment
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createDocumentFragment: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMDocumentFragment* ret = nsnull;
-  nsresult rv = doc->CreateDocumentFragment(&ret);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createDocumentFragment: failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::documentFragmentClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createDocumentFragment: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createDocumentFragment: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createElement
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Element;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createElement
-  (JNIEnv *env, jobject jthis, jstring jtagName)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jtagName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createElement: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMElement* ret = nsnull;
-  nsString* tagName = JavaDOMGlobals::GetUnicode(env, jtagName);
-  if (!tagName)
-      return NULL;
-  nsresult rv = doc->CreateElement(*tagName, &ret); 
-  nsString::Recycle(tagName);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createElement: failed", rv, exceptionType);
-
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::elementClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createElement: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createElement: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createEntityReference
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/EntityReference;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createEntityReference
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createEntityReference: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMEntityReference* ret = nsnull;
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-    return NULL;
-
-  nsresult rv = doc->CreateEntityReference(*name, &ret);  
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR ||
-         rv == NS_ERROR_DOM_NOT_SUPPORTED_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createEntityReference: failed", rv, exceptionType);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::entityReferenceClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createEntityReference: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createEntityReference: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createProcessingInstruction
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/ProcessingInstruction;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createProcessingInstruction
-  (JNIEnv *env, jobject jthis, jstring jtarget, jstring jdata)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jtarget || !jdata) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createProcessingInstruction: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMProcessingInstruction* ret = nsnull;
-  
-  nsString* target = JavaDOMGlobals::GetUnicode(env, jtarget);
-  if (!target)
-    return NULL;
-
-  nsString* data = JavaDOMGlobals::GetUnicode(env, jdata);
-  if (!data) {
-    nsString::Recycle(target);
-    return NULL;
-  }
-
-  nsresult rv = doc->CreateProcessingInstruction(*target, *data, &ret);
-  nsString::Recycle(target);
-  nsString::Recycle(data);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_NOT_SUPPORTED_ERR ||
-         rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createProcessingInstruction failed", rv, exceptionType);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::processingInstructionClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createProcessingInstruction: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createProcessingInstruction: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createTextNode
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Text;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createTextNode
-  (JNIEnv *env, jobject jthis, jstring jdata)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jdata) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createTextNode: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMText* ret = nsnull;
-  nsString* data = JavaDOMGlobals::GetUnicode(env, jdata);
-  if (!data)
-    return NULL;
-
-  nsresult rv = doc->CreateTextNode(*data, &ret);  
-  nsString::Recycle(data);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createTextNode failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::textClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createTextNode: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createTextNode: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    getDoctype
- * Signature: ()Lorg/w3c/dom/DocumentType;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_getDoctype
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc) 
-    return NULL;
-
-  nsIDOMDocumentType* docType = nsnull;
-  nsresult rv = doc->GetDoctype(&docType);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDoctype: failed", rv);
-    return NULL;
-  }
-  if (!docType)
-    return NULL;
-
-  jobject jDocType = env->AllocObject(JavaDOMGlobals::documentTypeClass);
-  if (!jDocType) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDoctype: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jDocType, JavaDOMGlobals::nodePtrFID, (jlong) docType);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDoctype: failed to set node ptr");
-    return NULL;
-  }
-
-  docType->AddRef();
-  return jDocType;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    getDocumentElement
- * Signature: ()Lorg/w3c/dom/Element;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_getDocumentElement
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDocumentElement: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMElement* element = nsnull;
-  nsresult rv = doc->GetDocumentElement(&element);
-  if (NS_FAILED(rv) || !element) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDocumentElement: failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::elementClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDocumentElement: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) element);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getDocumentElement: failed to set node ptr");
-    return NULL;
-  }
-
-  element->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    getElementsByTagName
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/NodeList;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_getElementsByTagName
-  (JNIEnv *env, jobject jthis, jstring jtagName)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jtagName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagName: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMNodeList* elements = nsnull;
-  nsString* tagName = JavaDOMGlobals::GetUnicode(env, jtagName);
-  if (!tagName)
-    return NULL;
-
-  nsresult rv = doc->GetElementsByTagName(*tagName, &elements);  
-  nsString::Recycle(tagName);
-
-  if (NS_FAILED(rv) || !elements) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagName: failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::nodeListClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagName: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) elements);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagName: failed to set node ptr");
-    return NULL;
-  }
-
-  elements->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    getImplementation
- * Signature: ()Lorg/w3c/dom/DOMImplementation;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_getImplementation
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getImplementation: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMDOMImplementation* impl = nsnull;
-  nsresult rv = doc->GetImplementation(&impl);
-  if (NS_FAILED(rv) || !impl) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getImplementation: failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::domImplementationClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getImplementation: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) impl);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getImplementation: failed to set node ptr");
-    return NULL;
-  }
-
-  impl->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    createEvent
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/events/Event;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_createEvent
-  (JNIEnv *env, jobject jthis, jstring jtype)
-{
-  nsISupports *doc = (nsISupports*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jtype) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createEvent: NULL pointer");
-    return NULL;
-  }
-
-  nsString* type = JavaDOMGlobals::GetUnicode(env, jtype);
-  if (!type)
-    return NULL;
-
-  nsIDOMDocumentEvent* docEvent = nsnull;
-  doc->QueryInterface(kIDOMDocumentEventIID, (void **) &docEvent);
-  if(!docEvent) {
-      JavaDOMGlobals::ThrowException(env,
-	  "Document.createEvent: NULL DOMDocumentEvent pointer");
-      return NULL;
-  }
-
-  nsIDOMEvent* event = nsnull;
-  nsresult rv = docEvent->CreateEvent(*type, &event);
-  nsString::Recycle(type);
-
-  if (NS_FAILED(rv) || !event) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.createEvent: failed", rv);
-    return NULL;
-  }
-
-  return JavaDOMEventsGlobals::CreateEventSubtype(env, event);
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    getElementsByTagNameNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/NodeList;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_getElementsByTagNameNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jlocalName)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jnamespaceURI || !jlocalName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagNameNS: NULL pointer");
-    return NULL;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-    return NULL;
-
-  nsString* localName = JavaDOMGlobals::GetUnicode(env, jlocalName);
-  if (!localName) {
-    nsString::Recycle(namespaceURI);
-    return NULL;
-  }
-
-  nsIDOMNodeList* elements = nsnull;
-
-  nsresult rv = doc->GetElementsByTagNameNS(*namespaceURI, *localName, &elements);  
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(localName);
-
-  if (NS_FAILED(rv) || !elements) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagNameNS: failed", rv);
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::nodeListClass);
-  if (!jret) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagNameNS: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::nodePtrFID, (jlong) elements);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementsByTagNameNS: failed to set node ptr");
-    return NULL;
-  }
-
-  elements->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentImpl
- * Method:    getElementById
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Element;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentImpl_getElementById
-  (JNIEnv *env, jobject jthis, jstring jelementId)
-{
-  nsIDOMDocument* doc = (nsIDOMDocument*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!doc || !jelementId) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementById: NULL pointer");
-    return NULL;
-  }
-
-  nsString* elementId = JavaDOMGlobals::GetUnicode(env, jelementId);
-  if (!elementId)
-    return NULL;
-
-  nsIDOMElement* element = nsnull;
-  nsresult rv = doc->GetElementById(*elementId, &element);  
-  nsString::Recycle(elementId);
-
-  if (NS_FAILED(rv) || !element) {
-    JavaDOMGlobals::ThrowException(env,
-      "Document.getElementById: failed", rv);
-    return NULL;
-  }
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, (nsIDOMNode*)element);
-}

mozilla/java/dom/jni/org_mozilla_dom_DocumentTypeImpl.cpp

@@ -1,243 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMDocumentType.h"
-#include "nsIDOMNamedNodeMap.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_DocumentTypeImpl.h"
-
-
-/*
- * Class:     org_mozilla_dom_DocumentTypeImpl
- * Method:    getEntities
- * Signature: ()Lorg/w3c/dom/NamedNodeMap;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentTypeImpl_getEntities
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocumentType* docType = (nsIDOMDocumentType*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!docType) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DocumentType.getEntities: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsIDOMNamedNodeMap* nodeMap = nsnull;
-  nsresult rv = docType->GetEntities(&nodeMap);
-  if (NS_FAILED(rv) || !nodeMap) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getEntities: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::namedNodeMapClass);
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getEntities: failed to allocate object\n"));
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::namedNodeMapPtrFID, (jlong) nodeMap);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getEntities: failed to set node ptr: %x\n", nodeMap));
-    return NULL;
-  }
-
-  nodeMap->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentTypeImpl
- * Method:    getName
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_DocumentTypeImpl_getName
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocumentType* docType = (nsIDOMDocumentType*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!docType) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DocumentType.getName: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = docType->GetName(ret);
-  if (NS_FAILED(rv)) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getName: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getName: NewString failed\n"));
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentTypeImpl
- * Method:    getNotations
- * Signature: ()Lorg/w3c/dom/NamedNodeMap;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_DocumentTypeImpl_getNotations
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocumentType* docType = (nsIDOMDocumentType*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!docType) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DocumentType.getNotations: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsIDOMNamedNodeMap* nodeMap = nsnull;
-  nsresult rv = docType->GetNotations(&nodeMap);
-  if (NS_FAILED(rv) || !nodeMap) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getNotations: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jobject jret = env->AllocObject(JavaDOMGlobals::namedNodeMapClass);
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getNotations: failed to allocate object\n"));
-    return NULL;
-  }
-
-  env->SetLongField(jret, JavaDOMGlobals::namedNodeMapPtrFID, (jlong) nodeMap);
-  if (env->ExceptionOccurred()) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getNotations: failed to set node ptr: %x\n", nodeMap));
-    return NULL;
-  }
-
-  nodeMap->AddRef();
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentTypeImpl
- * Method:    getPublicId
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_DocumentTypeImpl_getPublicId
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocumentType* docType = (nsIDOMDocumentType*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!docType) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DocumentType.getPublicId: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = docType->GetPublicId(ret);
-  if (NS_FAILED(rv)) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getPublicId: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getPublicId: NewString failed\n"));
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentTypeImpl
- * Method:    getSystemId
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_DocumentTypeImpl_getSystemId
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocumentType* docType = (nsIDOMDocumentType*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!docType) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DocumentType.getSystemId: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = docType->GetSystemId(ret);
-  if (NS_FAILED(rv)) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getSystemId: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getSystemId: NewString failed\n"));
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_DocumentTypeImpl
- * Method:    getInternalSubset
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_DocumentTypeImpl_getInternalSubset
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMDocumentType* docType = (nsIDOMDocumentType*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!docType) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("DocumentType.getInternalSubset: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = docType->GetInternalSubset(ret);
-  if (NS_FAILED(rv)) {
-      PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getInternalSubset: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("DocumentType.getInternalSubset: NewString failed\n"));
-  }
-
-  return jret;
-}

mozilla/java/dom/jni/org_mozilla_dom_ElementImpl.cpp

@@ -1,770 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMElement.h"
-#include "nsIDOMAttr.h"
-#include "nsIDOMNodeList.h"
-#include "nsDOMError.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_ElementImpl.h"
-
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getAttribute
- * Signature: (Ljava/lang/String;)Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_ElementImpl_getAttribute
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttribute: NULL pointer");
-    return NULL;
-  }
-
-  nsString* cname = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!cname)
-    return NULL;
-
-  nsString attr;
-  nsresult rv = element->GetAttribute(*cname, attr);  
-  nsString::Recycle(cname);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttribute: failed", rv);
-    return NULL;
-  }
-
-  jstring jattr = env->NewString(attr.GetUnicode(), attr.Length());
-  if (!jattr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttribute: NewString failed");
-    return NULL;
-  }
-
-  return jattr;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getAttributeNode
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Attr;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_getAttributeNode
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNode: NULL pointer");
-    return NULL;
-  }
-
-  nsString* cname = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!cname)
-    return NULL;
-
-  nsIDOMAttr* attr = nsnull;
-  nsresult rv = element->GetAttributeNode(*cname, &attr);  
-  nsString::Recycle(cname);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNode: failed", rv);
-    return NULL;
-  }
-  if (!attr)
-    return NULL;
-
-  jobject jattr = env->AllocObject(JavaDOMGlobals::attrClass);
-  if (!jattr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNode: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jattr, JavaDOMGlobals::nodePtrFID, (jlong) attr);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNode: failed to set node ptr");
-    return NULL;
-  }
-
-  attr->AddRef();
-  return jattr;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getElementsByTagName
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/NodeList;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_getElementsByTagName
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagName: NULL pointer");
-    return NULL;
-  }
-
-  nsString* cname = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!cname)
-    return NULL;
-
-  nsIDOMNodeList* nodes = nsnull;
-  nsresult rv = element->GetElementsByTagName(*cname, &nodes);
-  nsString::Recycle(cname);
-
-  if (NS_FAILED(rv) || !nodes) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagName: failed", rv);
-    return NULL;
-  }
-
-  jobject jnodes = env->AllocObject(JavaDOMGlobals::nodeListClass);
-  if (!jnodes) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagName: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jnodes, JavaDOMGlobals::nodeListPtrFID, (jlong) nodes);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagName: failed to set node ptr");
-    return NULL;
-  }
-
-  nodes->AddRef();
-  return jnodes;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getTagName
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_ElementImpl_getTagName
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getTagName: NULL pointer");
-    return NULL;
-  }
-
-  nsString tagName;
-  nsresult rv = element->GetTagName(tagName);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getTagName: failed", rv);
-    return NULL;
-  }
-
-  jstring jTagName = env->NewString(tagName.GetUnicode(), tagName.Length());
-  if (!jTagName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getTagName: NewString failed");
-    return NULL;
-  }
-
-  return jTagName;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    normalize
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_ElementImpl_normalize
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.normalize: NULL pointer");
-    return;
-  }
-
-  nsresult rv = element->Normalize();
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.normalize: failed", rv);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    removeAttribute
- * Signature: (Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_ElementImpl_removeAttribute
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttribute: NULL pointer");
-    return;
-  }
-
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-    return;
-
-  nsresult rv = element->RemoveAttribute(*name);  
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttribute: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    removeAttributeNode
- * Signature: (Lorg/w3c/dom/Attr;)Lorg/w3c/dom/Attr;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_removeAttributeNode
-  (JNIEnv *env, jobject jthis, jobject joldAttr)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !joldAttr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttributeNode: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* oldAttr = (nsIDOMAttr*) 
-    env->GetLongField(joldAttr, JavaDOMGlobals::nodePtrFID);
-  if (!oldAttr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttributeNode: NULL arg pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* ret = nsnull;
-  nsresult rv = element->RemoveAttributeNode(oldAttr, &ret);
-  if (NS_FAILED(rv) || !ret) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR ||
-         rv == NS_ERROR_DOM_NOT_FOUND_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttributeNode: failed", rv, exceptionType);
-    return NULL;
-  }
-
-  jobject jattr = env->AllocObject(JavaDOMGlobals::attrClass);
-  if (!jattr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttributeNode: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jattr, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttributeNode: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jattr;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    setAttribute
- * Signature: (Ljava/lang/String;Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_ElementImpl_setAttribute
-  (JNIEnv *env, jobject jthis, jstring jname, jstring jvalue)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jname || !jvalue) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttribute: NULL pointer");
-    return;
-  }
-
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-      return;
-
-  nsString* value = JavaDOMGlobals::GetUnicode(env, jvalue);
-  if (!value) {
-    nsString::Recycle(name);
-    return;
-  }
-
-  nsresult rv = element->SetAttribute(*name, *value);
-  nsString::Recycle(value);
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR ||
-         rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttribute: failed", rv, exceptionType);
-    return;
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    setAttributeNode
- * Signature: (Lorg/w3c/dom/Attr;)Lorg/w3c/dom/Attr;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_setAttributeNode
-  (JNIEnv *env, jobject jthis, jobject jnewAttr)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnewAttr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNode: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* newAttr = (nsIDOMAttr*) 
-    env->GetLongField(jnewAttr, JavaDOMGlobals::nodePtrFID);
-  if (!newAttr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNode: NULL arg pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* ret = nsnull;
-  nsresult rv = element->SetAttributeNode(newAttr, &ret);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR ||
-         rv == NS_ERROR_DOM_WRONG_DOCUMENT_ERR ||
-         rv == NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNode: failed", rv, exceptionType);
-    return NULL;
-  }
-  if (!ret)
-    return NULL;
-
-  jobject jattr = env->AllocObject(JavaDOMGlobals::attrClass);
-  if (!jattr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNode: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jattr, JavaDOMGlobals::nodePtrFID, (jlong) ret);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNode: failed to set node ptr");
-    return NULL;
-  }
-
-  ret->AddRef();
-  return jattr;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getAttributeNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_ElementImpl_getAttributeNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jlocalName)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnamespaceURI || !jlocalName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNS: NULL pointer");
-    return NULL;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return NULL;
-
-  nsString* localName = JavaDOMGlobals::GetUnicode(env, jlocalName);
-  if (!localName) {
-      nsString::Recycle(namespaceURI);
-      return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = element->GetAttributeNS(*namespaceURI, *localName, ret);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(localName);
-
-  if (NS_FAILED(rv)) {
-      JavaDOMGlobals::ThrowException(env,
-	  "Element.getAttributeNS: failed");
-      return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Element.getAttributeNS: NewString failed\n"));
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    setAttributeNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_ElementImpl_setAttributeNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jqualifiedName, jstring jvalue)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnamespaceURI || !jqualifiedName || !jvalue) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNS: NULL pointer");
-    return;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return;
-
-  nsString* qualifiedName = JavaDOMGlobals::GetUnicode(env, jqualifiedName);
-  if (!qualifiedName) {
-      nsString::Recycle(namespaceURI);
-      return;
-  }
-
-  nsString* value = JavaDOMGlobals::GetUnicode(env, jvalue);
-  if (!value) {
-      nsString::Recycle(namespaceURI);
-      nsString::Recycle(qualifiedName);
-      return;
-  }
-
-  nsresult rv = element->SetAttributeNS(*namespaceURI, *qualifiedName, *value);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(qualifiedName);
-  nsString::Recycle(value);
-
-  if (NS_FAILED(rv)) {
-      JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-      if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-	  (rv == NS_ERROR_DOM_INVALID_CHARACTER_ERR ||
-	   rv == NS_ERROR_DOM_NAMESPACE_ERR ||
-	   rv == NS_ERROR_DOM_WRONG_DOCUMENT_ERR)) {
-	  exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-      }
-      JavaDOMGlobals::ThrowException(env,
-	  "ElementImpl.setAttributeNS: failed", rv, exceptionType);
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    removeAttributeNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;)V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_ElementImpl_removeAttributeNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jlocalName)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnamespaceURI || !jlocalName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.removeAttributeNS: NULL pointer");
-    return;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return;
-
-  nsString* localName = JavaDOMGlobals::GetUnicode(env, jlocalName);
-  if (!localName) {
-      nsString::Recycle(namespaceURI);
-      return;
-  }
-
-  nsresult rv = element->RemoveAttributeNS(*namespaceURI, *localName);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(localName);
-
-  if (NS_FAILED(rv)) {
-      JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-      if (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR) {
-	  exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-      }
-      JavaDOMGlobals::ThrowException(env,
-	  "Element.removeAttributeNS: failed", rv, exceptionType);
-  }
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getAttributeNodeNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/Attr;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_getAttributeNodeNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jlocalName)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnamespaceURI || !jlocalName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNodeNS: NULL pointer");
-    return NULL;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return NULL;
-
-  nsString* localName = JavaDOMGlobals::GetUnicode(env, jlocalName);
-  if (!localName) {
-      nsString::Recycle(namespaceURI);
-      return NULL;
-  }
-
-  nsIDOMAttr* attr = nsnull;
-  nsresult rv = element->GetAttributeNodeNS(*namespaceURI, *localName, &attr);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(localName);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getAttributeNodeNS: failed", rv);
-    return NULL;
-  }
-  if (!attr)
-    return NULL;
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, (nsIDOMNode*)attr);
-}
-
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    setAttributeNodeNS
- * Signature: (Lorg/w3c/dom/Attr;)Lorg/w3c/dom/Attr;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_setAttributeNodeNS
-  (JNIEnv *env, jobject jthis, jobject jnewAttr)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnewAttr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNodeNS: NULL pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* newAttr = (nsIDOMAttr*) 
-    env->GetLongField(jnewAttr, JavaDOMGlobals::nodePtrFID);
-  if (!newAttr) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNodeNS: NULL arg pointer");
-    return NULL;
-  }
-
-  nsIDOMAttr* ret = nsnull;
-  nsresult rv = element->SetAttributeNodeNS(newAttr, &ret);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR ||
-         rv == NS_ERROR_DOM_WRONG_DOCUMENT_ERR ||
-         rv == NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "Element.setAttributeNodeNS: failed", rv, exceptionType);
-    return NULL;
-  }
-  if (!ret)
-    return NULL;
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, (nsIDOMNode*)ret);
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    getElementsByTagNameNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Lorg/w3c/dom/NodeList;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_ElementImpl_getElementsByTagNameNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jlocalName)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnamespaceURI || !jlocalName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagNameNS: NULL pointer");
-    return NULL;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return NULL;
-
-  nsString* localName = JavaDOMGlobals::GetUnicode(env, jlocalName);
-  if (!localName) {
-      nsString::Recycle(namespaceURI);
-      return NULL;
-  }
-
-  nsIDOMNodeList* nodes = nsnull;
-  nsresult rv = element->GetElementsByTagNameNS(*namespaceURI, *localName, &nodes);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(localName);
-
-  if (NS_FAILED(rv) || !nodes) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagNameNS: failed", rv);
-    return NULL;
-  }
-
-  jobject jnodes = env->AllocObject(JavaDOMGlobals::nodeListClass);
-  if (!jnodes) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagNameNS: failed to allocate object");
-    return NULL;
-  }
-
-  env->SetLongField(jnodes, JavaDOMGlobals::nodeListPtrFID, (jlong) nodes);
-  if (env->ExceptionOccurred()) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.getElementsByTagNameNS: failed to set node ptr");
-    return NULL;
-  }
-
-  nodes->AddRef();
-  return jnodes;
-}
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    hasAttribute
- * Signature: (Ljava/lang/String;)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_mozilla_dom_ElementImpl_hasAttribute
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.hasAttribute: NULL pointer");
-    return JNI_FALSE;
-  }
-
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-      return JNI_FALSE;
-
-  PRBool hasAttr = PR_FALSE;
-  nsresult rv = element->HasAttribute(*name, &hasAttr);
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.hasAttribute: failed", rv);
-    return JNI_FALSE;
-  }
-
-  return (hasAttr == PR_TRUE) ? JNI_TRUE : JNI_FALSE;
-}
-
-
-/*
- * Class:     org_mozilla_dom_ElementImpl
- * Method:    hasAttributeNS
- * Signature: (Ljava/lang/String;Ljava/lang/String;)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_mozilla_dom_ElementImpl_hasAttributeNS
-  (JNIEnv *env, jobject jthis, jstring jnamespaceURI, jstring jlocalName)
-{
-  nsIDOMElement* element = (nsIDOMElement*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!element || !jnamespaceURI || !jlocalName) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.hasAttributeNS: NULL pointer");
-    return JNI_FALSE;
-  }
-
-  nsString* namespaceURI = JavaDOMGlobals::GetUnicode(env, jnamespaceURI);
-  if (!namespaceURI)
-      return JNI_FALSE;
-
-  nsString* localName = JavaDOMGlobals::GetUnicode(env, jlocalName);
-  if (!localName) {
-      nsString::Recycle(namespaceURI);
-      return JNI_FALSE;
-  }
-
-  PRBool hasAttr = PR_FALSE;
-  nsresult rv = element->HasAttributeNS(*namespaceURI, *localName, &hasAttr);
-  nsString::Recycle(namespaceURI);
-  nsString::Recycle(localName);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "Element.hasAttributeNS: failed", rv);
-    return JNI_FALSE;
-  }
-
-  return (hasAttr == PR_TRUE) ? JNI_TRUE : JNI_FALSE;
-}

mozilla/java/dom/jni/org_mozilla_dom_EntityImpl.cpp

@@ -1,128 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMEntity.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_EntityImpl.h"
-
-
-/*
- * Class:     org_mozilla_dom_EntityImpl
- * Method:    getNotationName
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_EntityImpl_getNotationName
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMEntity* entity = (nsIDOMEntity*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!entity) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("Entity.getNotationName: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = entity->GetNotationName(ret);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Entity.getNotationName: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Entity.getNotationName: NewString failed\n"));
-    return NULL;
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_EntityImpl
- * Method:    getPublicId
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_EntityImpl_getPublicId
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMEntity* entity = (nsIDOMEntity*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!entity) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("Entity.getPublicId: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = entity->GetPublicId(ret);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Entity.getPublicId: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Entity.getPublicId: NewString failed\n"));
-    return NULL;
-  }
-
-  return jret;
-}
-
-/*
- * Class:     org_mozilla_dom_EntityImpl
- * Method:    getSystemId
- * Signature: ()Ljava/lang/String;
- */
-JNIEXPORT jstring JNICALL Java_org_mozilla_dom_EntityImpl_getSystemId
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMEntity* entity = (nsIDOMEntity*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodePtrFID);
-  if (!entity) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("Entity.getSystemId: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsString ret;
-  nsresult rv = entity->GetSystemId(ret);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Entity.getSystemId: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  jstring jret = env->NewString(ret.GetUnicode(), ret.Length());
-  if (!jret) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("Entity.getSystemId: NewString failed\n"));
-    return NULL;
-  }
-
-  return jret;
-}

mozilla/java/dom/jni/org_mozilla_dom_NamedNodeMapImpl.cpp

@@ -1,207 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMNamedNodeMap.h"
-#include "nsIDOMNode.h"
-#include "javaDOMGlobals.h"
-#include "nsDOMError.h"
-#include "org_mozilla_dom_NamedNodeMapImpl.h"
-
-
-/*
- * Class:     org_mozilla_dom_NamedNodeMapImpl
- * Method:    getLength
- * Signature: ()I
- */
-JNIEXPORT jint JNICALL Java_org_mozilla_dom_NamedNodeMapImpl_getLength
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMNamedNodeMap* map = (nsIDOMNamedNodeMap*) 
-    env->GetLongField(jthis, JavaDOMGlobals::namedNodeMapPtrFID);
-  if (!map) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.getLength: NULL pointer");
-    return 0;
-  }
-
-  PRUint32 length = 0;
-  nsresult rv = map->GetLength(&length);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.getLength: failed", rv);
-    return 0;
-  }
-
-  return (jint) length;
-}
-
-/*
- * Class:     org_mozilla_dom_NamedNodeMapImpl
- * Method:    getNamedItem
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Node;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_NamedNodeMapImpl_getNamedItem
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMNamedNodeMap* map = (nsIDOMNamedNodeMap*) 
-    env->GetLongField(jthis, JavaDOMGlobals::namedNodeMapPtrFID);
-  if (!map || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.getNamedItem: NULL pointer");
-    return NULL;
-  }
-  
-  nsIDOMNode* node = nsnull;
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-    return NULL;
-
-  nsresult rv = map->GetNamedItem(*name, &node);
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.getNamedItem: failed", rv);
-    return NULL;
-  }
-  if (!node)
-    return NULL;
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, node);
-}
-
-/*
- * Class:     org_mozilla_dom_NamedNodeMapImpl
- * Method:    item
- * Signature: (I)Lorg/w3c/dom/Node;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_NamedNodeMapImpl_item
-  (JNIEnv *env, jobject jthis, jint jindex)
-{
-  if (jindex < 0 || jindex > JavaDOMGlobals::javaMaxInt) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-     ("NamedNodeMap.item: invalid index value (%d)\n", jindex));
-    return NULL;
-  }
-
-  nsIDOMNamedNodeMap* map = (nsIDOMNamedNodeMap*) 
-    env->GetLongField(jthis, JavaDOMGlobals::namedNodeMapPtrFID);
-  if (!map) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.item: NULL pointer");
-    return NULL;
-  }
-  
-  nsIDOMNode* node = nsnull;
-  nsresult rv = map->Item((PRUint32) jindex, &node);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.item: failed", rv);
-    return NULL;
-  }
-  if (!node)
-    return NULL;
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, node);
-}
-
-/*
- * Class:     org_mozilla_dom_NamedNodeMapImpl
- * Method:    removeNamedItem
- * Signature: (Ljava/lang/String;)Lorg/w3c/dom/Node;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_NamedNodeMapImpl_removeNamedItem
-  (JNIEnv *env, jobject jthis, jstring jname)
-{
-  nsIDOMNamedNodeMap* map = (nsIDOMNamedNodeMap*) 
-    env->GetLongField(jthis, JavaDOMGlobals::namedNodeMapPtrFID);
-  if (!map || !jname) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.removeNamedItem: NULL pointer");
-    return NULL;
-  }
-  
-  nsIDOMNode* node = nsnull;
-  nsString* name = JavaDOMGlobals::GetUnicode(env, jname);
-  if (!name)
-    return NULL;
-
-  nsresult rv = map->RemoveNamedItem(*name, &node);
-  nsString::Recycle(name);
-
-  if (NS_FAILED(rv) || !node) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (rv == NS_ERROR_DOM_NOT_FOUND_ERR) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.removeNamedItem: failed", rv, exceptionType);
-    return NULL;
-  }
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, node);
-}
-
-/*
- * Class:     org_mozilla_dom_NamedNodeMapImpl
- * Method:    setNamedItem
- * Signature: (Lorg/w3c/dom/Node;)Lorg/w3c/dom/Node;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_NamedNodeMapImpl_setNamedItem
-  (JNIEnv *env, jobject jthis, jobject jarg)
-{
-  nsIDOMNamedNodeMap* map = (nsIDOMNamedNodeMap*) 
-    env->GetLongField(jthis, JavaDOMGlobals::namedNodeMapPtrFID);
-  if (!map || !jarg) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.setNamedItem: NULL pointer");
-    return NULL;
-  }
-  
-  nsIDOMNode* arg = (nsIDOMNode*)
-    env->GetLongField(jarg, JavaDOMGlobals::namedNodeMapPtrFID);
-  if (!arg) {
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.setNamedItem: NULL item pointer");
-    return NULL;
-  }
-
-  nsIDOMNode* node = nsnull;
-  nsresult rv = map->SetNamedItem(arg, &node);
-  if (NS_FAILED(rv)) {
-    JavaDOMGlobals::ExceptionType exceptionType = JavaDOMGlobals::EXCEPTION_RUNTIME;
-    if (NS_ERROR_GET_MODULE(rv) == NS_ERROR_MODULE_DOM &&
-        (rv == NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR ||
-         rv == NS_ERROR_DOM_WRONG_DOCUMENT_ERR ||
-         rv == NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR)) {
-      exceptionType = JavaDOMGlobals::EXCEPTION_DOM;
-    }
-    JavaDOMGlobals::ThrowException(env,
-      "NodeMap.setNamedItem: failed", rv, exceptionType);
-    return NULL;
-  }
-  if (!node)
-    return NULL;
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, node);
-}
-

mozilla/java/dom/jni/org_mozilla_dom_NodeListImpl.cpp

@@ -1,192 +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 Sun Microsystems,
- Inc. Portions created by Sun are
- Copyright (C) 1999 Sun Microsystems, Inc. All
- Rights Reserved.
-
- Contributor(s): 
-*/
-
-#include "prlog.h"
-#include "nsIDOMNode.h"
-#include "nsIDOMNodeList.h"
-#include "javaDOMGlobals.h"
-#include "org_mozilla_dom_NodeListImpl.h"
-
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-
-/*
- * Class:     org_mozilla_dom_NodeListImpl
- * Method:    XPCOM_equals
- * Signature: (Ljava/lang/Object;)Z
- */
-JNIEXPORT jboolean JNICALL Java_org_mozilla_dom_NodeListImpl_XPCOM_1equals
-  (JNIEnv *env, jobject jthis, jobject jarg)
-{
-  jboolean b_retFlag = JNI_FALSE;
-
-  nsIDOMNodeList* p_this = 
-    (nsIDOMNodeList*) env->GetLongField(jthis, JavaDOMGlobals::nodeListPtrFID);
-  if (!p_this) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("NodeList.equals: NULL pointer\n"));
-    return b_retFlag;
-  }
-
-  nsIDOMNodeList* p_arg = 
-    (nsIDOMNodeList*) env->GetLongField(jarg, JavaDOMGlobals::nodeListPtrFID);
-  if (!p_arg) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("NodeList.equals: NULL arg pointer\n"));
-    return b_retFlag;
-  }
-
-  nsISupports* thisSupports = nsnull;
-  nsISupports* argSupports = nsnull;
-
-  nsresult rvThis = 
-    p_this->QueryInterface(kISupportsIID, (void**)(&thisSupports));
-  if (NS_FAILED(rvThis) || !thisSupports) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("NodeList.equals: this->QueryInterface failed (%x)\n", rvThis));
-    return b_retFlag; 	
-  }
-
-  nsresult rvArg =
-    p_arg->QueryInterface(kISupportsIID, (void**)(&argSupports));
-  if (NS_FAILED(rvArg) || !argSupports) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("NodeList.equals: arg->QueryInterface failed (%x)\n", rvArg));
-    thisSupports->Release();
-    return b_retFlag;
-  }
-
-  if (thisSupports == argSupports)
-    b_retFlag = JNI_TRUE;
-  
-  thisSupports->Release();
-  argSupports->Release();
-
-  return b_retFlag;
-}
-
-/*
- * Class:     org_mozilla_dom_NodeListImpl
- * Method:    XPCOM_hashCode
- * Signature: ()I
- */
-JNIEXPORT jint JNICALL Java_org_mozilla_dom_NodeListImpl_XPCOM_1hashCode
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMNodeList* p_this = 
-    (nsIDOMNodeList*) env->GetLongField(jthis, JavaDOMGlobals::nodeListPtrFID);
-  if (!p_this) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("NodeList.hashCode: NULL pointer\n"));
-    return (jint) 0;
-  }
-
-  nsISupports* thisSupports = nsnull;
-  nsresult rvThis = 
-    p_this->QueryInterface(kISupportsIID, (void**)(&thisSupports));
-  if (NS_FAILED(rvThis) || !thisSupports) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("NodeList.hashCode: QueryInterface failed (%x)\n", rvThis));
-    return (jint) 0;
-  }
-
-  thisSupports->Release();
-  return (jint) thisSupports;
-}
-
-/*
- * Class:     org_mozilla_dom_NodeListImpl
- * Method:    finalize
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_org_mozilla_dom_NodeListImpl_finalize
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMNodeList* nodes = (nsIDOMNodeList*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodeListPtrFID);
-  if (!nodes) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("NodeList.finalize: NULL pointer\n"));
-    return;
-  }
-
-  JavaDOMGlobals::AddToGarbage(nodes);
-}
-
-/*
- * Class:     org_mozilla_dom_NodeListImpl
- * Method:    getLength
- * Signature: ()I
- */
-JNIEXPORT jint JNICALL Java_org_mozilla_dom_NodeListImpl_getLength
-  (JNIEnv *env, jobject jthis)
-{
-  nsIDOMNodeList* nodes = (nsIDOMNodeList*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodeListPtrFID);
-  if (!nodes) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("NodeList.getLength: NULL pointer\n"));
-    return 0;
-  }
-
-  PRUint32 length = 0;
-  nsresult rv = nodes->GetLength(&length);
-  if (NS_FAILED(rv)) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("NodeList.getLength: failed (%x)\n", rv));
-    return 0;
-  }
-
-  return (jint) length;
-}
-
-/*
- * Class:     org_mozilla_dom_NodeListImpl
- * Method:    item
- * Signature: (I)Lorg/w3c/dom/Node;
- */
-JNIEXPORT jobject JNICALL Java_org_mozilla_dom_NodeListImpl_item
-  (JNIEnv *env, jobject jthis, jint jindex)
-{
-  if (jindex < 0 || jindex > JavaDOMGlobals::javaMaxInt) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-     ("NodeList.item: invalid index value (%d)\n", jindex));
-    return NULL;
-  }
-
-  nsIDOMNodeList* nodes = (nsIDOMNodeList*) 
-    env->GetLongField(jthis, JavaDOMGlobals::nodeListPtrFID);
-  if (!nodes) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_WARNING, 
-	   ("NodeList.item: NULL pointer\n"));
-    return NULL;
-  }
-
-  nsIDOMNode* node = NULL;
-  nsresult rv = nodes->Item((PRUint32) jindex, &node);
-  if (NS_FAILED(rv) || !node) {
-    PR_LOG(JavaDOMGlobals::log, PR_LOG_ERROR, 
-	   ("NodeList.item: failed (%x)\n", rv));
-    return NULL;
-  }
-
-  return JavaDOMGlobals::CreateNodeSubtype(env, node);
-}
-