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,71 +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
-
-ifneq ($(BUILD_DOM_ONLY),)
-DIRS =	external \
-	util \
-	dom 
-else
-ifneq ($(BUILD_PLUGLETS_ONLY),)
-DIRS =	external \
-	util \
-	dom \
-	plugins 
-else
-ifneq ($(BUILD_WEBCLIENT_ONLY),)
-DIRS = 	external \
-	util \
-	dom \
-	xpcom \
-	webclient
-else
-ifneq ($(BUILD_BLACKCONNECT_ONLY),)
-DIRS = 	external \
-	util \
-	xpcom
-else
-ifneq ($(BUILD_BLACKWOOD),)
-DIRS =	external \
-	util \
-	dom \
-	xpcom \
-	webclient \
-	plugins 
-endif
-endif
-endif
-endif
-endif
-
-
-ifneq ($(PACKAGE_BUILD),)
-DIRS += build
-endif
-
-
-include $(topsrcdir)/config/rules.mk
-

mozilla/java/Makefile.win

@@ -1,82 +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 = ..
-
-!ifdef BUILD_DOM_ONLY
-DIRS = 	external \
-	util \
-	dom 
-!else
-!ifdef BUILD_PLUGLETS_ONLY
-DIRS =	external \
-	util \
-	dom \
-	plugins
-!else
-!ifdef BUILD_WEBCLIENT_ONLY
-DIRS = 	external \
-	util \
-	dom \
-	xpcom \
-	webclient \
-	build
-!else
-!ifdef BUILD_BLACKCONNECT_ONLY
-DIRS =	external \
-	util \
-	xpcom
-!else
-!ifdef BUILD_BLACKWOOD
-DIRS  = external \
-	util \
-	dom \
-	xpcom \
-	webclient \
-	plugins 
-!endif
-!endif
-!endif
-!endif
-!endif
-
-!ifdef PACKAGE_BUILD
-DIRS = $(DIRS)  build
-!endif
-
-include <$(DEPTH)\config\rules.mak>
-
-edburns:
-	echo $(DIRS)

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,104 +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"
-- Navigate to the url file:///opt/SUNWns6/res/javadev/pluglets/test.html
-
-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/build/Makefile.in

@@ -1,267 +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)
-
-JAVAHOME        = $(JDKHOME)
-include $(DEPTH)/config/autoconf.mk
-include $(topsrcdir)/config/rules.mk
-
-PACKAGE_DIR=$(topsrcdir)/dist/javadev
-PACKAGE_LIB=$(PACKAGE_DIR)/lib
-PACKAGE_EXAMPLE=$(PACKAGE_DIR)/example
-
-ifeq ($(PACKAGE_VER),)
-PACKAGE_VER=1.0
-endif
-
-
-ifeq ($(OS_ARCH),Linux)
-PACKAGE_OS=linux
-else
-PACKAGE_OS=solaris
-endif
-
-buildRunems:
-ifneq ($(BUILD_DOM_ONLY),)
-	if test ! -d $(PACKAGE_DIR) ; then mkdir $(PACKAGE_DIR) ; else true ; fi ;
-	if test ! -d $(PACKAGE_LIB) ; then mkdir $(PACKAGE_LIB) ; else true ; fi ;
-	if test ! -d $(PACKAGE_EXAMPLE) ; then mkdir $(PACKAGE_EXAMPLE) ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org ; then mkdir $(DIST)/../java/build/org ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org/mozilla ; then mkdir $(DIST)/../java/build/org/mozilla ; else true ; fi ;
-	cp -R $(DIST)/classes/org/mozilla/dom $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/util $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/w3c $(DIST)/../java/build/org
-	cd $(DIST)/../java/build
-	jar -cvfM0 JavaDOM_$(PACKAGE_VER)_$(PACKAGE_OS).jar org 
-	cp JavaDOM_$(PACKAGE_VER)_$(PACKAGE_OS).jar $(PACKAGE_LIB)/JavaDOM_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	rm -Rf $(DIST)/../java/build/org
-	rm -f $(DIST)/../java/build/JavaDOM_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	cp $(DIST)/bin/libjavadomjni.so $(PACKAGE_LIB)/libjavadomjni.so
-	cp $(DIST)/bin/components/libjavadom.so $(PACKAGE_LIB)/libjavadom.so
-	chmod 775 $(PACKAGE_LIB)/libjavadomjni.so
-	chmod 775 $(PACKAGE_LIB)/libjavadom.so
-	cp $(DIST)/../java/build/install_dom_unix.js $(DIST)/install.js
-	cp $(DIST)/../java/build/symlink.sh $(DIST)/symlink.sh
-	chmod 775 $(DIST)/symlink.sh
-	cp $(DIST)/../java/build/README.DOM $(PACKAGE_DIR)/README.DOM
-	cd $(DIST) ; \
-	zip -r JavaDOM_$(PACKAGE_VER)_$(PACKAGE_OS).xpi install.js symlink.sh javadev
-else
-ifneq ($(BUILD_PLUGLETS_ONLY),)
-	if test ! -d $(PACKAGE_DIR) ; then mkdir $(PACKAGE_DIR) ; else true ; fi ;
-	if test ! -d $(PACKAGE_LIB) ; then mkdir $(PACKAGE_LIB) ; else true ; fi ;
-	if test ! -d $(PACKAGE_EXAMPLE) ; then mkdir $(PACKAGE_EXAMPLE) ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org ; then mkdir $(DIST)/../java/build/org ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org/mozilla ; then mkdir $(DIST)/../java/build/org/mozilla ; else true ; fi ;
-	cp -R $(DIST)/classes/org/mozilla/util $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/dom $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/plugins $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/w3c $(DIST)/../java/build/org
-	cd $(DIST)/../java/build
-	jar -cvfM0 Pluglet_$(PACKAGE_VER)_$(PACKAGE_OS).jar org 
-	cp Pluglet_$(PACKAGE_VER)_$(PACKAGE_OS).jar $(PACKAGE_LIB)/Pluglet_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	rm -Rf $(DIST)/../java/build/org
-	rm -f $(DIST)/../java/build/Pluglet_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	cp $(DIST)/bin/libjavadomjni.so $(PACKAGE_LIB)/libjavadomjni.so
-	cp $(DIST)/bin/components/libjavadom.so $(PACKAGE_LIB)/libjavadom.so
-	cp $(DIST)/bin/libplugletjni.so $(PACKAGE_LIB)/libplugletjni.so
-	cp $(DIST)/bin/components/libpluglet.so $(PACKAGE_LIB)/libpluglet.so
-	chmod 775 $(PACKAGE_LIB)/libjavadomjni.so
-	chmod 775 $(PACKAGE_LIB)/libjavadom.so
-	chmod 775 $(PACKAGE_LIB)/libplugletjni.so
-	chmod 775 $(PACKAGE_LIB)/libpluglet.so
-	cp $(DIST)/../java/build/install_pluglet_unix.js $(DIST)/install.js
-	cp $(DIST)/../java/build/symlink.sh $(DIST)/symlink.sh
-	chmod 775 $(DIST)/symlink.sh
-	cp $(DIST)/../java/build/README.PLUGLET $(PACKAGE_DIR)/README.PLUGLET
-	cd $(DIST) ; \
-	zip -r Pluglet_$(PACKAGE_VER)_$(PACKAGE_OS).xpi install.js symlink.sh javadev
-else
-ifneq ($(BUILD_WEBCLIENT_ONLY),)
-	if test ! -d $(PACKAGE_DIR) ; then mkdir $(PACKAGE_DIR) ; else true ; fi ;
-	if test ! -d $(PACKAGE_LIB) ; then mkdir $(PACKAGE_LIB) ; else true ; fi ;
-	if test ! -d $(PACKAGE_EXAMPLE) ; then mkdir $(PACKAGE_EXAMPLE) ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org ; then mkdir $(DIST)/../java/build/org ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org/mozilla ; then mkdir $(DIST)/../java/build/org/mozilla ; else true ; fi ;
-	cp -R $(DIST)/classes/org/mozilla/util $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/dom $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/webclient $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/xpcom $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/w3c $(DIST)/../java/build/org
-	cd $(DIST)/../java/build
-	jar -cvfM0 Webclient_$(PACKAGE_VER)_$(PACKAGE_OS).jar org 
-	cp Webclient_$(PACKAGE_VER)_$(PACKAGE_OS).jar $(PACKAGE_LIB)/Webclient_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	rm -Rf $(DIST)/../java/build/org
-	rm -f $(DIST)/../java/build/Webclient_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	cp $(DIST)/bin/libjavadomjni.so $(PACKAGE_LIB)/libjavadomjni.so
-	cp $(DIST)/bin/components/libjavadom.so $(PACKAGE_LIB)/libjavadom.so
-	cp $(DIST)/bin/libwebclient.so $(PACKAGE_LIB)/libwebclient.so
-	cp $(DIST)/bin/libwebclientstub.so $(PACKAGE_LIB)/libwebclientstub.so
-	cp $(DIST)/lib/libwc_share.a $(PACKAGE_LIB)/libwc_share.a
-	cp $(DIST)/bin/components/libbcorb.so $(PACKAGE_LIB)/libbcorb.so
-	cp $(DIST)/bin/components/libbcjavastubs.so $(PACKAGE_LIB)/libbcjavastubs.so
-	cp $(DIST)/bin/components/libjavaloader.so $(PACKAGE_LIB)/libjavaloader.so
-	cp $(DIST)/bin/components/libjavaSample.so $(PACKAGE_LIB)/libjavaSample.so
-	cp $(DIST)/bin/components/libbcxpcomstubs.so $(PACKAGE_LIB)/libbcxpcomstubs.so
-	cp $(DIST)/bin/regxpcom $(PACKAGE_LIB)/regxpcom
-	chmod 775 $(PACKAGE_LIB)/libbcorb.so
-	chmod 775 $(PACKAGE_LIB)/libbcjavastubs.so
-	chmod 775 $(PACKAGE_LIB)/libjavaloader.so
-	chmod 775 $(PACKAGE_LIB)/libjavaSample.so
-	chmod 775 $(PACKAGE_LIB)/libbcxpcomstubs.so
-	chmod 775 $(PACKAGE_LIB)/regxpcom
-	chmod 775 $(PACKAGE_LIB)/libjavadomjni.so
-	chmod 775 $(PACKAGE_LIB)/libjavadom.so
-	chmod 775 $(PACKAGE_LIB)/libwebclient.so
-	chmod 775 $(PACKAGE_LIB)/libwebclientstub.so
-	chmod 775 $(PACKAGE_LIB)/libwc_share.a
-	@echo +++ Creating Commercial Package. Use runem.bat to run the test browser.
-	rm -f runem_unix_commercial.bat
-	@echo copy ../lib/libwebclient.so ../.. >> runem_unix_commercial.bat
-	@echo copy ../lib/libwebclientstub.so ../.. >> runem_unix_commercial.bat
-	@echo copy ../lib/libjavadom.so ../../components >> runem_unix_commercial.bat
-	@echo copy ../lib/libjavadomjni.so ../.. >> runem_unix_commercial.bat
-	@echo setenv CLASSPATH ../lib/Webclient_$(PACKAGE_VER)_$(PACKAGE_OS).jar>> runem_unix_commercial.bat
-	@echo $(PERL) ./runem.pl org.mozilla.webclient.test.EmbeddedMozilla $(DEPTH) %1% >> runem_unix_commercial.bat
-	cp -f runem_unix_commercial.bat $(PACKAGE_EXAMPLE)/runem.bat
-	cp -f $(DIST)/../java/webclient/src_share/runem.pl $(PACKAGE_EXAMPLE)/runem.pl
-	chmod 775 $(PACKAGE_EXAMPLE)/runem.bat
-	chmod 775 $(PACKAGE_EXAMPLE)/runem.pl
-	cp $(DIST)/../java/build/install_webclient_unix.js $(DIST)/install.js
-	cp $(DIST)/../java/build/symlink.sh $(DIST)/symlink.sh
-	chmod 775 $(DIST)/symlink.sh
-	cp $(DIST)/../java/build/README.WEBCLIENT $(PACKAGE_DIR)/README.WEBCLIENT
-	cd $(DIST) ; \
-	zip -r Webclient_$(PACKAGE_VER)_$(PACKAGE_OS).xpi install.js symlink.sh javadev
-else
-ifneq ($(BUILD_BLACKCONNECT_ONLY),)
-	if test ! -d $(PACKAGE_DIR) ; then mkdir $(PACKAGE_DIR) ; else true ; fi ;
-	if test ! -d $(PACKAGE_LIB) ; then mkdir $(PACKAGE_LIB) ; else true ; fi ;
-	if test ! -d $(PACKAGE_EXAMPLE) ; then mkdir $(PACKAGE_EXAMPLE) ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org ; then mkdir $(DIST)/../java/build/org ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org/mozilla ; then mkdir $(DIST)/../java/build/org/mozilla ; else true ; fi ;
-	cp -R $(DIST)/classes/org/mozilla/util $(DIST)/../java/build/org/mozilla
-	cp -R $(DIST)/classes/org/mozilla/xpcom $(DIST)/../java/build/org/mozilla
-	cd $(DIST)/../java/build
-	jar -cvfM0 Blackconnect_$(PACKAGE_VER)_$(PACKAGE_OS).jar org 
-	cp Blackconnect_$(PACKAGE_VER)_$(PACKAGE_OS).jar $(PACKAGE_LIB)/Blackconnect_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	rm -Rf $(DIST)/../java/build/org
-	rm -f $(DIST)/../java/build/Blackconnect_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	cp $(DIST)/bin/components/libbcorb.so $(PACKAGE_LIB)/libbcorb.so
-	cp $(DIST)/bin/components/libbcjavastubs.so $(PACKAGE_LIB)/libbcjavastubs.so
-	cp $(DIST)/bin/components/libjavaloader.so $(PACKAGE_LIB)/libjavaloader.so
-	cp $(DIST)/bin/components/libjavaSample.so $(PACKAGE_LIB)/libjavaSample.so
-	cp $(DIST)/bin/components/libbcxpcomstubs.so $(PACKAGE_LIB)/libbcxpcomstubs.so
-	cp $(DIST)/bin/regxpcom $(PACKAGE_LIB)/regxpcom
-	chmod 775 $(PACKAGE_LIB)/libbcorb.so
-	chmod 775 $(PACKAGE_LIB)/libbcjavastubs.so
-	chmod 775 $(PACKAGE_LIB)/libjavaloader.so
-	chmod 775 $(PACKAGE_LIB)/libjavaSample.so
-	chmod 775 $(PACKAGE_LIB)/libbcxpcomstubs.so
-	chmod 775 $(PACKAGE_LIB)/regxpcom
-	cp $(DIST)/../java/build/install_blackconnect_unix.js $(DIST)/install.js
-	cp $(DIST)/../java/build/symlink.sh $(DIST)/symlink.sh
-	chmod 775 $(DIST)/symlink.sh
-	cp $(DIST)/../java/build/README.BLACKCONNECT $(PACKAGE_DIR)/README.BLACKCONNECT
-	cd $(DIST) ; \
-	zip -r Blackconnect_$(PACKAGE_VER)_$(PACKAGE_OS).xpi install.js symlink.sh javadev
-else
-ifneq ($(BUILD_BLACKWOOD),)
-	if test ! -d $(PACKAGE_DIR) ; then mkdir $(PACKAGE_DIR) ; else true ; fi ;
-	if test ! -d $(PACKAGE_LIB) ; then mkdir $(PACKAGE_LIB) ; else true ; fi ;
-	if test ! -d $(PACKAGE_EXAMPLE) ; then mkdir $(PACKAGE_EXAMPLE) ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org ; then mkdir $(DIST)/../java/build/org ; else true ; fi ;
-	if test ! -d $(DIST)/../java/build/org/mozilla ; then mkdir $(DIST)/../java/build/org/mozilla ; else true ; fi ;
-	cp -R $(DIST)/classes/org/mozilla $(DIST)/../java/build/org
-	cp -R $(DIST)/classes/org/w3c $(DIST)/../java/build/org
-	cd $(DIST)/../java/build
-	jar -cvfM0 Blackwood_$(PACKAGE_VER)_$(PACKAGE_OS).jar org 
-	cp Blackwood_$(PACKAGE_VER)_$(PACKAGE_OS).jar $(PACKAGE_LIB)/Blackwood_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	rm -Rf $(DIST)/../java/build/org
-	rm -f $(DIST)/../java/build/Blackwood_$(PACKAGE_VER)_$(PACKAGE_OS).jar
-	cp $(DIST)/bin/libjavadomjni.so $(PACKAGE_LIB)/libjavadomjni.so
-	cp $(DIST)/bin/components/libjavadom.so $(PACKAGE_LIB)/libjavadom.so
-	cp $(DIST)/bin/libplugletjni.so $(PACKAGE_LIB)/libplugletjni.so
-	cp $(DIST)/bin/components/libpluglet.so $(PACKAGE_LIB)/libpluglet.so
-	cp $(DIST)/bin/libwebclient.so $(PACKAGE_LIB)/libwebclient.so
-	cp $(DIST)/bin/libwebclientstub.so $(PACKAGE_LIB)/libwebclientstub.so
-	cp $(DIST)/lib/libwc_share.a $(PACKAGE_LIB)/libwc_share.a
-	cp $(DIST)/bin/components/libbcorb.so $(PACKAGE_LIB)/libbcorb.so
-	cp $(DIST)/bin/components/libbcjavastubs.so $(PACKAGE_LIB)/libbcjavastubs.so
-	cp $(DIST)/bin/components/libjavaloader.so $(PACKAGE_LIB)/libjavaloader.so
-	cp $(DIST)/bin/components/libjavaSample.so $(PACKAGE_LIB)/libjavaSample.so
-	cp $(DIST)/bin/components/libbcxpcomstubs.so $(PACKAGE_LIB)/libbcxpcomstubs.so
-	cp $(DIST)/bin/regxpcom $(PACKAGE_LIB)/regxpcom
-	chmod 775 $(PACKAGE_LIB)/libjavadomjni.so
-	chmod 775 $(PACKAGE_LIB)/libjavadom.so
-	chmod 775 $(PACKAGE_LIB)/libplugletjni.so
-	chmod 775 $(PACKAGE_LIB)/libpluglet.so
-	chmod 775 $(PACKAGE_LIB)/libwebclient.so
-	chmod 775 $(PACKAGE_LIB)/libwebclientstub.so
-	chmod 775 $(PACKAGE_LIB)/libwc_share.a
-	chmod 775 $(PACKAGE_LIB)/libbcorb.so
-	chmod 775 $(PACKAGE_LIB)/libbcjavastubs.so
-	chmod 775 $(PACKAGE_LIB)/libjavaloader.so
-	chmod 775 $(PACKAGE_LIB)/libjavaSample.so
-	chmod 775 $(PACKAGE_LIB)/libbcxpcomstubs.so
-	chmod 775 $(PACKAGE_LIB)/regxpcom
-	@echo +++ Creating Commercial Package. Use runem.bat to run the test browser.
-	rm -f runem_unix_commercial.bat
-	@echo copy ../lib/libwebclient.so ../.. >> runem_unix_commercial.bat
-	@echo copy ../lib/libwebclientstub.so ../.. >> runem_unix_commercial.bat
-	@echo copy ../lib/libjavadom.so ../../components >> runem_unix_commercial.bat
-	@echo copy ../lib/libjavadomjni.so ../.. >> runem_unix_commercial.bat
-	@echo copy ../lib/libplugletjni.so ../.. >> runem_unix_commercial.bat
-	@echo copy ../lib/libpluglet.so ../../components >> runem_unix_commercial.bat
-	@echo setenv CLASSPATH ../lib/Blackwood_$(PACKAGE_VER)_$(PACKAGE_OS).jar>> runem_unix_commercial.bat
-	@echo $(PERL) ./runem.pl org.mozilla.webclient.test.EmbeddedMozilla $(DEPTH) %1% >> runem_unix_commercial.bat
-	cp -f runem_unix_commercial.bat $(PACKAGE_EXAMPLE)/runem.bat
-	cp -f $(DIST)/../java/webclient/src_share/runem.pl $(PACKAGE_EXAMPLE)/runem.pl
-	chmod 775 $(PACKAGE_EXAMPLE)/runem.bat
-	chmod 775 $(PACKAGE_EXAMPLE)/runem.pl
-	cp $(DIST)/../java/build/install_blackwood_unix.js $(DIST)/install.js
-	cp $(DIST)/../java/build/symlink.sh $(DIST)/symlink.sh
-	chmod 775 $(DIST)/symlink.sh
-	cp $(DIST)/../java/build/README.BLACKWOOD $(PACKAGE_DIR)/README.BLACKWOOD
-	cd $(DIST) ; \
-	zip -r Blackwood_$(PACKAGE_VER)_$(PACKAGE_OS).xpi install.js symlink.sh javadev
-endif #BLACKWOOD
-endif #BLACKCONNECT
-endif #WEBCLIENT
-endif #PLUGLETS
-endif #DOM
-
-
-
-install::buildRunems 
-
-
-clobber::
-	rm -f $(DIST)/*.zip
-	rm -f $(DIST)/*.js
-	rm -rf $(DIST)/javadev
-	rm -f $(DIST)/symlink.sh
-
-
-clobber_all::clobber
-
-
-clean::clobber

mozilla/java/build/Makefile.win

@@ -1,240 +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
-
-JAVAHOME        = $(JDKHOME)
-include <$(DEPTH)\config\rules.mak>
-
-PACKAGE_DIR = $(DEPTH)\dist\javadev
-PACKAGE_LIB = $(PACKAGE_DIR)\lib
-PACKAGE_EXAMPLE = $(PACKAGE_DIR)\example
-
-!ifndef PACKAGE_VER
-PACKAGE_VER = 1.0
-!endif
-
-
-buildRunems:
-!ifdef BUILD_DOM_ONLY
-	-mkdir $(PACKAGE_DIR)
-	-mkdir $(PACKAGE_LIB)
-	-mkdir $(PACKAGE_EXAMPLE)
-	-mkdir $(DIST)\..\java\build\org
-	-mkdir $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\dom $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\util $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\w3c $(DIST)\..\java\build\org
-	cd $(DIST)\..\java\build
-	jar -cvfM0 JavaDOM_$(PACKAGE_VER)_win32.jar org 
-	copy JavaDOM_$(PACKAGE_VER)_win32.jar ..\..\javadev\lib\JavaDOM_$(PACKAGE_VER)_win32.jar
-	cd ..\..\..\java\build
-	rmdir /S/Q $(DIST)\..\java\build\org
-	del /Q $(DIST)\..\java\build\JavaDOM_$(PACKAGE_VER)_win32.jar
-	copy $(DIST)\bin\javadomjni.dll $(PACKAGE_LIB)\javadomjni.dll
-	copy $(DIST)\bin\components\javadom.dll $(PACKAGE_LIB)\javadom.dll
-	chmod 775 $(PACKAGE_LIB)\javadomjni.dll
-	chmod 775 $(PACKAGE_LIB)\javadom.dll
-	copy install_dom_win32.js $(DIST)\..\install.js
-	copy README.DOM $(PACKAGE_DIR)\README.DOM
-	cd $(DIST)\..
-	zip -r JavaDOM_$(PACKAGE_VER)_win32.xpi install.js javadev
-	cd ..\java\build
-!else
-!ifdef BUILD_PLUGLETS_ONLY
-	-mkdir $(PACKAGE_DIR)
-	-mkdir $(PACKAGE_LIB)
-	-mkdir $(PACKAGE_EXAMPLE)
-	-mkdir $(DIST)\..\java\build\org
-	-mkdir $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\util $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\dom $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\plugins $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\w3c $(DIST)\..\java\build\org
-	cd $(DIST)\..\java\build
-	jar -cvfM0 Pluglet_$(PACKAGE_VER)_win32.jar org 
-	copy Pluglet_$(PACKAGE_VER)_win32.jar ..\..\javadev\lib\Pluglet_$(PACKAGE_VER)_win32.jar
-	cd ..\..\..\java\build
-	rmdir /S/Q $(DIST)\..\java\build\org
-	del /Q $(DIST)\..\java\build\Pluglet_$(PACKAGE_VER)_win32.jar
-	copy $(DIST)\bin\javadomjni.dll $(PACKAGE_LIB)\javadomjni.dll
-	copy $(DIST)\bin\components\javadom.dll $(PACKAGE_LIB)\javadom.dll
-	copy $(DIST)\bin\plugletjni.dll $(PACKAGE_LIB)\plugletjni.dll
-	copy $(DIST)\bin\components\pluglet.dll $(PACKAGE_LIB)\pluglet.dll
-	chmod 775 $(PACKAGE_LIB)\javadomjni.dll
-	chmod 775 $(PACKAGE_LIB)\javadom.dll
-	chmod 775 $(PACKAGE_LIB)\plugletjni.dll
-	chmod 775 $(PACKAGE_LIB)\pluglet.dll
-	copy install_pluglet_win32.js $(DIST)\..\install.js
-	copy README.PLUGLET $(PACKAGE_DIR)\README.PLUGLET
-	cd $(DIST)\..
-	zip -r Pluglet_$(PACKAGE_VER)_win32.xpi install.js javadev
-	cd ..\java\build
-!else
-!ifdef BUILD_WEBCLIENT_ONLY
-	-mkdir $(PACKAGE_DIR)
-	-mkdir $(PACKAGE_LIB)
-	-mkdir $(PACKAGE_EXAMPLE)
-	-mkdir $(DIST)\..\java\build\org
-	-mkdir $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\util $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\dom $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\webclient $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\xpcom $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\w3c $(DIST)\..\java\build\org
-	cd $(DIST)\..\java\build
-	jar -cvfM0 Webclient_$(PACKAGE_VER)_win32.jar org 
-	copy Webclient_$(PACKAGE_VER)_win32.jar ..\..\javadev\lib\Webclient_$(PACKAGE_VER)_win32.jar
-	cd ..\..\..\java\build
-	rmdir /S/Q $(DIST)\..\java\build\org
-	del /Q $(DIST)\..\java\build\Webclient_$(PACKAGE_VER)_win32.jar
-	copy $(DIST)\bin\javadomjni.dll $(PACKAGE_LIB)\javadomjni.dll
-	copy $(DIST)\bin\components\javadom.dll $(PACKAGE_LIB)\javadom.dll
-	copy $(DIST)\bin\webclient.dll $(PACKAGE_LIB)\webclient.dll
-	copy $(DIST)\lib\wc_share.lib $(PACKAGE_LIB)\wc_share.lib
-	copy $(DIST)\bin\components\bcorb.dll $(PACKAGE_LIB)\bcorb.dll
-	copy $(DIST)\bin\components\bcjavastubs.dll $(PACKAGE_LIB)\bcjavastubs.dll
-	copy $(DIST)\bin\components\bcjavaloader.dll $(PACKAGE_LIB)\bcjavaloader.dll
-	copy $(DIST)\bin\components\bcxpcomstubs.dll $(PACKAGE_LIB)\bcxpcomstubs.dll
-	copy $(DIST)\bin\regxpcom.exe $(PACKAGE_LIB)\regxpcom.exe
-	chmod 775 $(PACKAGE_LIB)\bcorb.dll
-	chmod 775 $(PACKAGE_LIB)\bcjavastubs.dll
-	chmod 775 $(PACKAGE_LIB)\bcjavaloader.dll
-	chmod 775 $(PACKAGE_LIB)\bcxpcomstubs.dll
-	chmod 775 $(PACKAGE_LIB)\regxpcom.exe
-	chmod 775 $(PACKAGE_LIB)\javadomjni.dll
-	chmod 775 $(PACKAGE_LIB)\javadom.dll
-	chmod 775 $(PACKAGE_LIB)\webclient.dll
-	chmod 775 $(PACKAGE_LIB)\wc_share.lib
-	@echo +++ Creating Commercial Package. Use runem.bat to run the test browser.
-	del /Q runem_win_commercial.bat
-	@echo set CLASSPATH=..\lib\Webclient_$(PACKAGE_VER)_win32.jar > runem_win_commercial.bat
-	@echo $(PERL) .\runem.pl org.mozilla.webclient.test.EmbeddedMozilla $(DEPTH) %1% >> runem_win_commercial.bat
-	copy runem_win_commercial.bat $(PACKAGE_EXAMPLE)\runem.bat
-	copy $(DIST)\..\..\java\webclient\src_share\runem.pl $(PACKAGE_EXAMPLE)\runem.pl
-	chmod 775 $(PACKAGE_EXAMPLE)\runem.bat
-	chmod 775 $(PACKAGE_EXAMPLE)\runem.pl
-	copy install_webclient_win32.js $(DIST)\..\install.js
-	copy README.WEBCLIENT $(PACKAGE_DIR)\README.WEBCLIENT
-	cd $(DIST)\..
-	zip -r Webclient_$(PACKAGE_VER)_win32.xpi install.js javadev
-	cd ..\java\build
-!else
-!ifdef BUILD_BLACKCONNECT_ONLY
-	-mkdir $(PACKAGE_DIR)
-	-mkdir $(PACKAGE_LIB)
-	-mkdir $(PACKAGE_EXAMPLE)
-	-mkdir $(DIST)\..\java\build\org
-	-mkdir $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\util $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\xpcom $(DIST)\..\java\build\org\mozilla
-	cd $(DIST)\..\java\build
-	jar -cvfM0 Blackconnect_$(PACKAGE_VER)_win32.jar org 
-	copy Blackconnect_$(PACKAGE_VER)_win32.jar ..\..\javadev\lib\Blackconnect_$(PACKAGE_VER)_win32.jar
-	cd ..\..\..\java\build
-	rmdir /S/Q $(DIST)\..\java\build\org
-	del /Q $(DIST)\..\java\build\Blackconnect_$(PACKAGE_VER)_win32.jar
-	copy $(DIST)\bin\components\bcorb.dll $(PACKAGE_LIB)\bcorb.dll
-	copy $(DIST)\bin\components\bcjavastubs.dll $(PACKAGE_LIB)\bcjavastubs.dll
-	copy $(DIST)\bin\components\bcjavaloader.dll $(PACKAGE_LIB)\bcjavaloader.dll
-	copy $(DIST)\bin\components\bcxpcomstubs.dll $(PACKAGE_LIB)\bcxpcomstubs.dll
-	copy $(DIST)\bin\regxpcom.exe $(PACKAGE_LIB)\regxpcom.exe
-	chmod 775 $(PACKAGE_LIB)\bcorb.dll
-	chmod 775 $(PACKAGE_LIB)\bcjavastubs.dll
-	chmod 775 $(PACKAGE_LIB)\bcjavaloader.dll
-	chmod 775 $(PACKAGE_LIB)\bcxpcomstubs.dll
-	chmod 775 $(PACKAGE_LIB)\regxpcom.exe
-	copy install_blackconnect_win32.js $(DIST)\..\install.js
-	copy README.BLACKCONNECT $(PACKAGE_DIR)\README.BLACKCONNECT
-	cd $(DIST)\..
-	zip -r Blackconnect_$(PACKAGE_VER)_win32.xpi install.js javadev
-	cd ..\java\build
-!else
-!ifdef BUILD_BLACKWOOD
-	-mkdir $(PACKAGE_DIR)
-	-mkdir $(PACKAGE_LIB)
-	-mkdir $(PACKAGE_EXAMPLE)
-	-mkdir $(DIST)\..\java\build\org
-	-mkdir $(DIST)\..\java\build\org\mozilla
-	xcopy /E $(DIST)\..\classes\org\mozilla\* $(DIST)\..\java\build\org
-	xcopy /E $(DIST)\..\classes\org\w3c $(DIST)\..\java\build\org
-	cd $(DIST)\..\java\build
-	jar -cvfM0 Blackwood_$(PACKAGE_VER)_win32.jar org 
-	copy Blackwood_$(PACKAGE_VER)_win32.jar ..\..\javadev\lib\Blackwood_$(PACKAGE_VER)_win32.jar
-	cd ..\..\..\java\build
-	rmdir /S/Q $(DIST)\..\java\build\org
-	del /Q $(DIST)\..\java\build\Blackwood_$(PACKAGE_VER)_win32.jar
-	copy $(DIST)\bin\javadomjni.dll $(PACKAGE_LIB)\javadomjni.dll
-	copy $(DIST)\bin\components\javadom.dll $(PACKAGE_LIB)\javadom.dll
-	copy $(DIST)\bin\plugletjni.dll $(PACKAGE_LIB)\plugletjni.dll
-	copy $(DIST)\bin\components\pluglet.dll $(PACKAGE_LIB)\pluglet.dll
-	copy $(DIST)\bin\webclient.dll $(PACKAGE_LIB)\webclient.dll
-	copy $(DIST)\lib\wc_share.lib $(PACKAGE_LIB)\wc_share.lib
-	copy $(DIST)\bin\components\bcorb.dll $(PACKAGE_LIB)\bcorb.dll
-	copy $(DIST)\bin\components\bcjavastubs.dll $(PACKAGE_LIB)\bcjavastubs.dll
-	copy $(DIST)\bin\components\bcjavaloader.dll $(PACKAGE_LIB)\bcjavaloader.dll
-	copy $(DIST)\bin\components\bcxpcomstubs.dll $(PACKAGE_LIB)\bcxpcomstubs.dll
-	copy $(DIST)\bin\regxpcom.exe $(PACKAGE_LIB)\regxpcom.exe
-	chmod 775 $(PACKAGE_LIB)\javadomjni.dll
-	chmod 775 $(PACKAGE_LIB)\javadom.dll
-	chmod 775 $(PACKAGE_LIB)\plugletjni.dll
-	chmod 775 $(PACKAGE_LIB)\pluglet.dll
-	chmod 775 $(PACKAGE_LIB)\webclient.dll
-	chmod 775 $(PACKAGE_LIB)\wc_share.lib
-	chmod 775 $(PACKAGE_LIB)\bcorb.dll
-	chmod 775 $(PACKAGE_LIB)\bcjavastubs.dll
-	chmod 775 $(PACKAGE_LIB)\bcjavaloader.dll
-	chmod 775 $(PACKAGE_LIB)\bcxpcomstubs.dll
-	chmod 775 $(PACKAGE_LIB)\regxpcom.exe
-	@echo +++ Creating Commercial Package. Use runem.bat to run the test browser.
-	del /Q runem_win_commercial.bat
-	@echo set CLASSPATH=..\lib\Blackwood_$(PACKAGE_VER)_win32.jar > runem_win_commercial.bat
-	@echo $(PERL) .\runem.pl org.mozilla.webclient.test.EmbeddedMozilla $(DEPTH) %1% >> runem_win_commercial.bat
-	copy runem_win_commercial.bat $(PACKAGE_EXAMPLE)\runem.bat
-	copy $(DIST)\..\..\java\webclient\src_share\runem.pl $(PACKAGE_EXAMPLE)\runem.pl
-	chmod 775 $(PACKAGE_EXAMPLE)\runem.bat
-	chmod 775 $(PACKAGE_EXAMPLE)\runem.pl
-	copy install_blackwood_win32.js $(DIST)\..\install.js
-	copy README.BLACKWOOD $(PACKAGE_DIR)\README.BLACKWOOD
-	cd $(DIST)\..
-	zip -r Blackwood_$(PACKAGE_VER)_win32.xpi install.js javadev
-	cd ..\java\build
-!endif #BLACKWOOD
-!endif #BLACKCONNECT
-!endif #WEBCLIENT
-!endif #PLUGLETS
-!endif #DOM
-
-
-install::buildRunems 
-
-
-clobber::
-	rm -rf $(DIST)\..\*.xpi
-	rm -rf $(DIST)\..\javadev
-	rm -rf $(DIST)\..\java
-
-
-clobber_all::clobber
-
-
-clean::clobber

mozilla/java/build/README.BLACKCONNECT

@@ -1,78 +0,0 @@
-Black Connect
-================================
-
-This directory contains the Black Connect
-
-The sources is divided into three directories
-
-   connect
-      public headers. 
-      ORB implementation.
-      
-   xpcom
-      XPCOM stubs and proxy implementation
-      
-   java
-      JAVA stubs and proxy implementation
-      Java component loader
-
-===============================================
-Solaris directions  
-===============================================
-
-Requirements:
-
-* current mozilla built tree
-
-* JDK1.3 
-
-* Perl 5 must be in your path
-
-How To Build:
-
-*  make sure the environment var JDKHOME is set to your jdk installation
-   directory, ie export  JDKHOME=/usr/local/jdk1.3
-   
-* Add following directories to to your LD_LIBRARY_PATH:
-   
-
-$MOZILLA_FIVE_HOME:$JDKHOME/jre/lib/$HOSTTYPE/native_threads:$JDKHOME/jre/lib/$HOSTTYPE/classic:
-$JDKHOME/jre/lib/$HOSTTYPE/:
-
-* type "gmake"
-
-
-==============================================
-Linux directions  
-===============================================
-
-Requirements:
-
-* mozilla m16 build tree
-
-* JDK1.3 from IBM 
-
-* Perl 5 must be in your path
-
-How To Build:
-
-*  make sure the environment var JDKHOME is set to your jdk installation
-   directory, ie export  JDKHOME=/usr/local/jdk1.3
-   
-* Add following directories to to your LD_LIBRARY_PATH:
-   
-$MOZILLA_FIVE_HOME:$JDKHOME/jre/bin:$JDKHOME/jre/bin/classic:
-
-* remove jni* jri* from MOZILLA_FIVE_HOME/dist/include
-
-* type "gmake"
-
-==============================================
-How to run test java component
-===============================================
-* cd java/test
-* gmake
-* add $MOZILLA_FIVE_HOME/dist/classes to your CLASSPATH
-Test component would be placed in dist/bin/componets and loaded on mozilla
-sturtup (or you can use regxpcom for testing)
-

mozilla/java/build/README.BLACKWOOD

@@ -1,95 +0,0 @@
-Here lies the MozWebShell java wrapper to mozilla M8.
-
-Authors: Kirk Baker <kbaker@eb.com>
-         Ian Wilkinson <iw@ennoble.co>
-
-Build hacking and packaging: Ed Burns <edburns@acm.org>
-
-Unix port: Mark Lin <mark.lin@eng.sun.com>
-
-========================================================================
-Win32 Build Directions:
-========================================================================
-Requirements:
-
-* built mozilla with source code from after 10/5/99
-
-* JDK1.1.7 or greater
-
-* built org.mozilla.util java classes (see NOTE_UTIL)
-
-* Perl 5 perl.exe must be in your path
-
-How To Build:
-
-* Follow the directions in ..\README
-
-* type "nmake /f makefile.win all" and hope for the best
-
-How to Run:
-
-* once the build has successfully completed, run this batch file:
-
-  .\src\WIN32_D.OBJ\runem.bat <opt: YOUR_URL>
-
-  Note that YOUR_URL is probably necessary since firewall support wasn't
-  working in M8.
-
-
-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
-
-========================================================================
-Unix Build Directions (currently only Linux, 
-Solaris support is coming soon):
-========================================================================
-Requirements:
-
-* built mozilla tree for some variant of Linux
-
-* JDK1.2 with native threads support from http://www.blackdown.org 
-(JDK1.1 doesn't seem to work)
-
-* built org.mozilla.util java classes (see NOTE_UTIL)
-
-How To Build:
-
-* Follow the directions in ../util/README
-
-* set JDKHOME to where your JDK install directory resides 
-	-> setenv JDKHOME /usr/local/jdk1.2
-
-* cd to 'classes' and type "make -f makefile.unix" and hope for the best
-	-> cd classes; make -f Makefile.unix
-
-* then cd to 'src' and type "make -f makefile.unix" and hope for the best
-	-> cd src; make -f Makefile.unix
-
-How to Run:
-
-* once the build has successfully completed, run 'runem.unix' in your
-'src' directory:
-	-> cd src; ./runem.unix <YOUR_URL>
-
-  Note that YOUR_URL is probably necessary since firewall support wasn't
-  working in M8.
-
-Problems? Email mark.lin@eng.sun.com or post to netscape.public.mozilla.java.
-
-========================================================================
-NOTE_UTIL:
-========================================================================
-* this package depends on the org.mozilla.util classes, which can be
-  found in the mozilla tree under mozilla\java\util.  They are a
-  separate checkout and build.  Once you check out the org.mozilla.util
-  classes, see the README in the mozilla\java\util\README.
-
-General notes:
-
-* Please update the ChangeLog (changelo) when you make changes.
-
-

mozilla/java/build/README.DOM

@@ -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/build/README.PLUGLET

@@ -1,105 +0,0 @@
-Java-Implemented Plug-ins.
-================================
-http://www.mozilla.org/projects/blackwood/java-plugins/
---------------------------------
-This directory contains the beginnings of the Java-Implemented plug-uns.
-
-The sources is divided into four directories
-
-	classes
-	       Java source files
-	src 
-	       Native code (c++/c)
-	jni
-	       Implamentations of java native methods
-	test
-	       Test code, including simple pluglet.
-
-========================================================================
-Win32 Directions:
-========================================================================
-Requirements:
-
-* current mozilla built tree
-
-* JDK1.3 or JDK1.2 if you are not using OJI
-
-* Perl 5 perl.exe must be in your path
-
-How To Build:
-
-*  make sure the environment var JDKHOME is set to your jdk installation
-   directory, ie SET JDKHOME=C:\jdk1.2
-
-* if you do not have working OJI set OJI_DISABLE to 1
-  (You can do it in your command prompt, or you can set it in 
-   mozilla/java/plugins/src/makefile.win).
-
-* type "nmake /f makefile.win"
-
-How to Run:
-
-* Add following directories to to your path:
-  %MOZILLA_FIVE_HOME%
-  In case OJI_DISABLE add %JDKHOME%\jre\bin\client to your path
-
-* Copy class files from mozilla/dist/classes to your JRE/lib/ext directory and
-add JRE/lib/ext to your classpath
- 
-How to build and run test
-* go to the test directory and type "nmake /f makefile.win"
-
-* Set PLUGLET environment to the  directory you have test.jar
-
-* Run mozilla and load page test.html from test directory and if everething is ok you will see
-  some awt demo.
-
-
-=========================================================================
-Unix (Sparc Solaris and i386 Linux) Directions:
-=========================================================================
-
-Requirements:
-
-* current mozilla built tree
-
-* JDK1.3 
-
-* Perl 5 must be in your path
-
-How To Build:
-
-*  make sure the environment var JDKHOME is set to your jdk installation
-   directory, ie export  JDKHOME=/usr/local/jdk1.3
-
-* Add following directories to to your LD_LIBRARY_PATH:
-
-$MOZILLA_FIVE_HOME:$JDKHOME/jre/lib/$HOSTTYPE/native_threads:$JDKHOME/jre/lib/$HOSTTYPE/client:
-$JDKHOME/jre/lib/$HOSTTYPE/:
-
-* type "gmake"
-     
-How to Run:
-	 
-* Add $MOZILLA_FILE_HOME/../classes to your CLASSPATH
-
-How to build and run test
-
-* go to the test directory and type "gmake"
-  test.jar will be placed  in mozilla/dist/bin/plugins directory
-
-* set LD_PRELOAD to libXm.so (to libawt.so on linux platform)
-
-* Run mozilla and load page resource:///res/javadev/pluglets/test.html and if everething is ok you will see  some awt demo.
-  
-  
-========================================================================
-
-Problems:
-
-* post to netscape.public.mozilla.java newsgroup
-
-
-
-
-

mozilla/java/build/README.WEBCLIENT

@@ -1,95 +0,0 @@
-Here lies the MozWebShell java wrapper to mozilla M8.
-
-Authors: Kirk Baker <kbaker@eb.com>
-         Ian Wilkinson <iw@ennoble.co>
-
-Build hacking and packaging: Ed Burns <edburns@acm.org>
-
-Unix port: Mark Lin <mark.lin@eng.sun.com>
-
-========================================================================
-Win32 Build Directions:
-========================================================================
-Requirements:
-
-* built mozilla with source code from after 10/5/99
-
-* JDK1.1.7 or greater
-
-* built org.mozilla.util java classes (see NOTE_UTIL)
-
-* Perl 5 perl.exe must be in your path
-
-How To Build:
-
-* Follow the directions in ..\README
-
-* type "nmake /f makefile.win all" and hope for the best
-
-How to Run:
-
-* once the build has successfully completed, run this batch file:
-
-  .\src\WIN32_D.OBJ\runem.bat <opt: YOUR_URL>
-
-  Note that YOUR_URL is probably necessary since firewall support wasn't
-  working in M8.
-
-
-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
-
-========================================================================
-Unix Build Directions (currently only Linux, 
-Solaris support is coming soon):
-========================================================================
-Requirements:
-
-* built mozilla tree for some variant of Linux
-
-* JDK1.2 with native threads support from http://www.blackdown.org 
-(JDK1.1 doesn't seem to work)
-
-* built org.mozilla.util java classes (see NOTE_UTIL)
-
-How To Build:
-
-* Follow the directions in ../util/README
-
-* set JDKHOME to where your JDK install directory resides 
-	-> setenv JDKHOME /usr/local/jdk1.2
-
-* cd to 'classes' and type "make -f makefile.unix" and hope for the best
-	-> cd classes; make -f Makefile.unix
-
-* then cd to 'src' and type "make -f makefile.unix" and hope for the best
-	-> cd src; make -f Makefile.unix
-
-How to Run:
-
-* once the build has successfully completed, run 'runem.unix' in your
-'src' directory:
-	-> cd src; ./runem.unix <YOUR_URL>
-
-  Note that YOUR_URL is probably necessary since firewall support wasn't
-  working in M8.
-
-Problems? Email mark.lin@eng.sun.com or post to netscape.public.mozilla.java.
-
-========================================================================
-NOTE_UTIL:
-========================================================================
-* this package depends on the org.mozilla.util classes, which can be
-  found in the mozilla tree under mozilla\java\util.  They are a
-  separate checkout and build.  Once you check out the org.mozilla.util
-  classes, see the README in the mozilla\java\util\README.
-
-General notes:
-
-* Please update the ChangeLog (changelo) when you make changes.
-
-

mozilla/java/build/install_blackconnect_unix.js

@@ -1,86 +0,0 @@
-// Installation guide for BlackConnect.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
-// this function creates a symlink
-function symlink(lnk, tgt)
-{
-    var err = execute("symlink.sh", tgt + " " + lnk);
-    logComment("execute symlink.sh "+tgt+" "+lnk+" returned: "+err);
-}
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("BlackConnect", "BlackConnect", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   symlink(fComponents + "libbcorb.so", 
-           getFolder(fJavadev, "lib/libbcorb.so"));
-   symlink(fComponents + "libbcjavastubs.so", 
-           getFolder(fJavadev, "lib/libbcjavastubs.so"));
-   symlink(fComponents + "libjavaloader.so", 
-           getFolder(fJavadev, "lib/libjavaloader.so"));
-   symlink(fComponents + "libjavaSample.so", 
-           getFolder(fJavadev, "lib/libjavaSample.so"));
-   symlink(fComponents + "libbcTest.so", 
-           getFolder(fJavadev, "lib/libbcTest.so"));
-   symlink(fComponents + "libbcxpcomstubs.so", 
-           getFolder(fJavadev, "lib/libbcxpcomstubs.so"));
-   symlink(fProgram + "regxpcom", 
-           getFolder(fJavadev, "lib/regxpcom"));
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_blackconnect_win32.js

@@ -1,76 +0,0 @@
-// Installation guide for BlackConnect.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("BlackConnect", "BlackConnect", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   src = getFolder(fJavadev, "lib/bcorb.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcjavastubs.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/javaloader.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcxpcomstubs.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "regxpcom.exe");
-   err = File.copy(src, fProgram);
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_blackwood_unix.js

@@ -1,90 +0,0 @@
-// Installation guide for Blackwood.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
-// this function creates a symlink
-function symlink(lnk, tgt)
-{
-    var err = execute("symlink.sh", tgt + " " + lnk);
-    logComment("execute symlink.sh "+tgt+" "+lnk+" returned: "+err);
-}
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("Blackwood", "Blackwood", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   symlink(fComponents + "libjavadom.so", 
-           getFolder(fJavadev, "lib/libjavadom.so"));
-   symlink(fComponents + "libpluglet.so", 
-           getFolder(fJavadev, "lib/libpluglet.so"));
-   symlink(fComponents + "libbcorb.so", 
-           getFolder(fJavadev, "lib/libbcorb.so"));
-   symlink(fComponents + "libbcjavastubs.so", 
-           getFolder(fJavadev, "lib/libbcjavastubs.so"));
-   symlink(fComponents + "libjavaloader.so", 
-           getFolder(fJavadev, "lib/libjavaloader.so"));
-   symlink(fComponents + "libjavaSample.so", 
-           getFolder(fJavadev, "lib/libjavaSample.so"));
-   symlink(fComponents + "libbcTest.so", 
-           getFolder(fJavadev, "lib/libbcTest.so"));
-   symlink(fComponents + "libbcxpcomstubs.so", 
-           getFolder(fJavadev, "lib/libbcxpcomstubs.so"));
-   symlink(fProgram + "regxpcom", 
-           getFolder(fJavadev, "lib/regxpcom"));
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_blackwood_win32.js

@@ -1,80 +0,0 @@
-// Installation guide for Blackwood.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
- logComment("Starting Install Process");
- err    = initInstall("Blackwood", "Blackwood", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   src = getFolder(fJavadev, "lib/javadom.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/pluglet.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcorb.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcjavastubs.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/javaloader.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcxpcomstubs.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "regxpcom.exe");
-   err = File.copy(src, fProgram);
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_dom_unix.js

@@ -1,74 +0,0 @@
-// Installation guide for JavaDOM.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
-// this function creates a symlink
-function symlink(lnk, tgt)
-{
-    var err = execute("symlink.sh", tgt + " " + lnk);
-    logComment("execute symlink.sh "+tgt+" "+lnk+" returned: "+err);
-}
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("JavaDOM", "JavaDOM", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   symlink(fComponents + "libjavadom.so", 
-           getFolder(fJavadev, "lib/libjavadom.so"));
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_dom_win32.js

@@ -1,68 +0,0 @@
-// Installation guide for JavaDOM.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("JavaDOM", "JavaDOM", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   src = getFolder(fJavadev, "lib/javadom.dll");
-   err = File.copy(src, fComponents);
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_pluglets_unix.js

@@ -1,76 +0,0 @@
-// Installation guide for Pluglets.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
-// this function creates a symlink
-function symlink(lnk, tgt)
-{
-    var err = execute("symlink.sh", tgt + " " + lnk);
-    logComment("execute symlink.sh "+tgt+" "+lnk+" returned: "+err);
-}
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("Pluglets", "Pluglets", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   symlink(fComponents + "libjavadom.so", 
-           getFolder(fJavadev, "lib/libjavadom.so"));
-   symlink(fComponents + "libpluglet.so", 
-           getFolder(fJavadev, "lib/libpluglet.so"));
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_pluglets_win32.js

@@ -1,70 +0,0 @@
-// Installation guide for Pluglets.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("Pluglets", "Pluglets", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   src = getFolder(fJavadev, "lib/javadom.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/pluglet.dll");
-   err = File.copy(src, fComponents);
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_webclient_unix.js

@@ -1,88 +0,0 @@
-// Installation guide for Webclient.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
-// this function creates a symlink
-function symlink(lnk, tgt)
-{
-    var err = execute("symlink.sh", tgt + " " + lnk);
-    logComment("execute symlink.sh "+tgt+" "+lnk+" returned: "+err);
-}
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("Webclient", "Webclient", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   symlink(fComponents + "libjavadom.so", 
-           getFolder(fJavadev, "lib/libjavadom.so"));
-   symlink(fComponents + "libbcorb.so", 
-           getFolder(fJavadev, "lib/libbcorb.so"));
-   symlink(fComponents + "libbcjavastubs.so", 
-           getFolder(fJavadev, "lib/libbcjavastubs.so"));
-   symlink(fComponents + "libjavaloader.so", 
-           getFolder(fJavadev, "lib/libjavaloader.so"));
-   symlink(fComponents + "libjavaSample.so", 
-           getFolder(fJavadev, "lib/libjavaSample.so"));
-   symlink(fComponents + "libbcTest.so", 
-           getFolder(fJavadev, "lib/libbcTest.so"));
-   symlink(fComponents + "libbcxpcomstubs.so", 
-           getFolder(fJavadev, "lib/libbcxpcomstubs.so"));
-   symlink(fProgram + "regxpcom", 
-           getFolder(fJavadev, "lib/regxpcom"));
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/install_webclient_win32.js

@@ -1,78 +0,0 @@
-// Installation guide for Webclient.xpi
- // this function verifies disk space in kilobytes
- function verifyDiskSpace(dirPath, spaceRequired)
- {
-   var spaceAvailable;
- 
-   // Get the available disk space on the given path
-   spaceAvailable = fileGetDiskSpaceAvailable(dirPath);
- 
-   // Convert the available disk space into kilobytes
-   spaceAvailable = parseInt(spaceAvailable / 1024);
- 
-   // do the verification
-   if(spaceAvailable < spaceRequired)
-   {
-     logComment("Insufficient disk space: " + dirPath);
-     logComment("  required : " + spaceRequired + " K");
-     logComment("  available: " + spaceAvailable + " K");
-     return(false);
-   }
- 
-   return(true);
- }
- 
- 
- // main
- var srDest;
- var err;
- var fProgram;
- 
- srDest = 1000;
-logComment("Starting Install Process");
- err    = initInstall("Webclient", "Webclient", "1.0"); 
- logComment("initInstall: " + err);
- 
- fProgram = getFolder("Program");
- logComment("fProgram: " + fProgram);
- 
- if(verifyDiskSpace(fProgram, srDest))
- {
-   setPackageFolder(fProgram);
-   err = addDirectory("",
-     "1.0",
-     "javadev", // dir name in jar to extract 
-     fProgram, // Where to put this file 
-               // (Returned from GetFolder) 
-     "javadev", // subdir name to create relative to fProgram
-     true); // Force Flag 
-   logComment("addDirectory() returned: " + err);
-
-   var fComponents     = getFolder("Components");
-   var fJavadev        = getFolder("Program","javadev");
-   src = getFolder(fJavadev, "lib/javadom.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcorb.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcjavastubs.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/javaloader.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "lib/bcxpcomstubs.dll");
-   err = File.copy(src, fComponents);
-   src = getFolder(fJavadev, "regxpcom.exe");
-   err = File.copy(src, fProgram);
-
-   // check return value
-   if(err == SUCCESS)
-   {
-     err = performInstall(); 
-     logComment("performInstall() returned: " + err);
-   }
-   else
-     cancelInstall(err);
- }
- else
-   cancelInstall(INSUFFICIENT_DISK_SPACE);
- 
- // end main

mozilla/java/build/symlink.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-
-#-------------------------------------------------------
-# Hack to allow symlinking (required for Sun's JRE) in
-# a zippy.
-#
-# usage: symlink.sh <srcfile> <newlink>
-#
-#-------------------------------------------------------
-
-ln -s $1 $2

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.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/blackconnect/dom/Makefile

@@ -1,36 +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):
-# Igor Kushnirskiy <idk@eng.sun.com>
-#
-DEPTH   = ../../../..
-topsrcdir       = ../../../..
-VPATH           = .
-srcdir          = .
-
-include $(DEPTH)/config/autoconf.mk
-
-DIRS=   \
-        classes \
-	stubs   \
-	accessor    \
-        $(NULL)
-
-include $(topsrcdir)/config/rules.mk

mozilla/java/dom/blackconnect/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 stubs accessor
-
-include $(topsrcdir)/config/rules.mk

mozilla/java/dom/blackconnect/dom/accessor/Makefile.in

@@ -1,56 +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
-
-MODULE		= DOMAccessor
-COMPONENT	= DOMAccessor
-LIBRARY_NAME    = DOMAccessor
-IS_COMPONENT    = 1
-XPIDL_MODULE	= DOMAccessor
-XPIDLSRCS	= bcIDOMAccessor.idl
-
-CPPSRCS       = bcDOMAccessor.cpp \
-		$(NULL)
-
-EXTRA_LIBS = -ljavadomstubs -L$(DIST)/lib
-
-include $(topsrcdir)/config/rules.mk
-
-bcDOMAccessor.jar.comp: manifest bcIDOMAccessor.class bcDOMAccessor.class 
-	$(JDKHOME)/bin/jar cvfm bcDOMAccessor.jar.comp  manifest *.class
-.java.class:
-	$(JDKHOME)/bin/javac -classpath $(CLASSPATH) $<
-install-component: bcDOMAccessor.jar.comp bcDOMAccessor.jar.info
-	cp  bcDOMAccessor.jar.comp bcDOMAccessor.jar.info $(DEPTH)/dist/bin/components/
-
-clobber-java:
-	rm -f *.class *.jar
-clobber:: clobber-java
-clobber_all:: clobber-java
-install:: install-component

mozilla/java/dom/blackconnect/dom/accessor/bcDOMAccessor.cpp

@@ -1,244 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- * 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):
- * Denis Sharypov <sdv@sparc.spb.su>
- */
-#include "bcIDOMAccessor.h"
-
-#include "nsIGenericFactory.h"
-#include "nsIModule.h"
-#include "nsIServiceManager.h"
-#include "nsCURILoader.h"
-#include "nsIURL.h"
-#include "nsIChannel.h"
-#include "nsIDocument.h"
-#include "nsIDocumentLoader.h"
-#include "nsIDocumentLoaderObserver.h"
-#include "nsIDocumentViewer.h"
-#include "nsIDOMDocument.h"
-#include "nsIDocShell.h"
-#include "bcNode.h"
-#include "bcDocument.h"
-#include "bcElement.h"
-
-//  #include "nsIEnumerator.h"
-//  #include "stdlib.h"
-
-static nsIDOMDocument* GetDocument(nsIDocumentLoader* loader);
-#if defined(DEBUG)
-#include <stdio.h>
-#include "nsIDOMElement.h"
-#include "nsIDOMNodeList.h"
-#include "nsIDOMNamedNodeMap.h"
-#endif
-
-static NS_DEFINE_IID(kIDocShellIID, NS_IDOCSHELL_IID);
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-static NS_DEFINE_IID(kIDocumentViewerIID, NS_IDOCUMENT_VIEWER_IID);
-static NS_DEFINE_IID(kIDOMDocumentIID, NS_IDOMDOCUMENT_IID);
-static NS_DEFINE_IID(kIDocumentLoaderObserverIID, NS_IDOCUMENT_LOADER_OBSERVER_IID);
-
-/* 151dd030-9ed0-11d4-a983-00105ae3801e */
-#define BC_DOM_ACCESSOR_CID \
-{0x151dd030, 0x9ed0, 0x11d4, \
-{0xa9, 0x83, 0x00, 0x10, 0x5a, 0xe3, 0x80, 0x1e}}
-
-static NS_DEFINE_IID(kDocLoaderServiceCID, NS_DOCUMENTLOADER_SERVICE_CID);
-
-class bcDOMAccessor : public bcIDOMAccessor, public nsIDocumentLoaderObserver
-{
-public:
-  NS_DECL_ISUPPORTS
-  NS_DECL_BCIDOMACCESSOR
-  NS_DECL_NSIDOCUMENTLOADEROBSERVER
-      
-  bcDOMAccessor(bcIDOMAccessor* accessor);
-    virtual ~bcDOMAccessor();
-    /* additional members */
-private:
-    bcIDOMAccessor* accessor;  
-    
-};
-
-/* Implementation file */
-NS_IMPL_ISUPPORTS1(bcDOMAccessor, bcIDOMAccessor)
-
-bcDOMAccessor::bcDOMAccessor(bcIDOMAccessor* accessor)
-{
-  NS_INIT_ISUPPORTS();
-  this->accessor = accessor;
-  /* member initializers and constructor code */
-}
-
-bcDOMAccessor::~bcDOMAccessor()
-{
-  /* destructor code */
-}
-
-NS_IMETHODIMP bcDOMAccessor::EndDocumentLoad(const char *url, Document* doc)
-//  NS_IMETHODIMP bcDOMAccessor::EndDocumentLoad(const char *url, Node *node, Element *elem)
-{
-    // wrap bcDOMDocumentImpl(doc)
-  // addref(bcDOMDocumentImpl)
-    if (accessor)
-        accessor->EndDocumentLoad(url, doc);
-//          accessor->EndDocumentLoad(url, node, elem);
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* void onStartDocumentLoad (in nsIDocumentLoader aLoader, in nsIURI aURL, in string aCommand); */
-NS_IMETHODIMP bcDOMAccessor::OnStartDocumentLoad(nsIDocumentLoader *aLoader, nsIURI *aURL, const char *aCommand)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* void onEndDocumentLoad (in nsIDocumentLoader loader, in nsIChannel aChannel, in unsigned long aStatus); */
-NS_IMETHODIMP bcDOMAccessor::OnEndDocumentLoad(nsIDocumentLoader *loader, nsIChannel *aChannel, PRUint32 aStatus)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* void onStartURLLoad (in nsIDocumentLoader aLoader, in nsIChannel channel); */
-NS_IMETHODIMP bcDOMAccessor::OnStartURLLoad(nsIDocumentLoader *aLoader, nsIChannel *channel)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* void onProgressURLLoad (in nsIDocumentLoader aLoader, in nsIChannel aChannel, in unsigned long aProgress, in unsigned long aProgressMax); */
-NS_IMETHODIMP bcDOMAccessor::OnProgressURLLoad(nsIDocumentLoader *aLoader, nsIChannel *aChannel, PRUint32 aProgress, PRUint32 aProgressMax)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/* [noscript] void onStatusURLLoad (in nsIDocumentLoader loader, in nsIChannel channel, in nsStringRef aMsg); */
-NS_IMETHODIMP bcDOMAccessor::OnStatusURLLoad(nsIDocumentLoader *loader, nsIChannel *channel, nsString & aMsg)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-
-/* void onEndURLLoad (in nsIDocumentLoader aLoader, 
-                      in nsIChannel aChannel, 
-                      in unsigned long aStatus); */
-
-NS_IMETHODIMP bcDOMAccessor::OnEndURLLoad(nsIDocumentLoader *loader, 
-                                          nsIChannel *channel, 
-                                          PRUint32 aStatus)
-{
-  char* urlSpec = (char*) "";
-  nsIURI* url = nsnull;
-  if (channel && NS_SUCCEEDED(channel->GetURI(&url)))
-    url->GetSpec(&urlSpec);
-
-  nsIDOMDocument* domDoc = GetDocument(loader);
-  nsIDOMElement* docEl;
-  domDoc->GetDocumentElement(&docEl);
-  nsIDOMNode* node = nsnull;
-  nsresult rv = domDoc->QueryInterface(NS_GET_IID(nsIDOMNode), (void**)&node);
-  // nb: error check
-  EndDocumentLoad(urlSpec, new bcDocument(domDoc));
-  return NS_OK;
-}
-
-void test() {
-    printf("--DOMAccessor test start\n");
-    nsresult rv = NS_OK; 
-    bcIDOMAccessor *accessor = NULL;
-    rv = nsComponentManager::CreateInstance("bcDOMAccessor",
-					   nsnull,
-					   NS_GET_IID(bcIDOMAccessor),
-					   (void**)&accessor);
-    if (NS_FAILED(rv)) {
-        printf(" === [debug] can not load bcDOMAccessor\n");
-        return;
-    }
-    NS_WITH_SERVICE(nsIDocumentLoader, docLoaderService, kDocLoaderServiceCID, &rv);
-    if (NS_FAILED(rv) || !docLoaderService) {
-        printf("=== no doc loader found...\n");
-    } else {
-        rv = docLoaderService->AddObserver((nsIDocumentLoaderObserver*)(new bcDOMAccessor(accessor)));
-        if (NS_FAILED(rv)) {
-            printf("=== AddObserver(DOMAccessor) failed x\n", rv);
-        }
-    }
-    printf("--DOMAccessor test end\n");
-}
-
-static int counter = 0;  //we do not need to call it on unload time;
-extern "C" NS_EXPORT nsresult NSGetModule(nsIComponentManager *compMgr,
-                                          nsIFile *location,
-                                          nsIModule** result)  //I am using it for runnig test *only*
-{
-  if (counter == 0) {
-    counter ++;
-    printf("--DOMAccessor before test\n");
-    test();
-    printf("--DOMAccessor after test\n");
-  }
-  return NS_ERROR_FAILURE;
-}
-
-static nsIDOMDocument* GetDocument(nsIDocumentLoader* loader)
-{
-    nsIDocShell* docshell = nsnull;
-    nsISupports* container = nsnull;
-    nsIContentViewer* contentv = nsnull;
-    nsIDocumentViewer* docv = nsnull;
-    nsIDocument* document = nsnull;
-    nsIDOMDocument* domDoc = nsnull;
-    
-    nsresult rv = loader->GetContainer(&container);
-    if (NS_SUCCEEDED(rv) && container) {
-        rv = container->QueryInterface(kIDocShellIID, (void**) &docshell);
-        container->Release();
-        if (NS_SUCCEEDED(rv) && docshell) {
-            rv = docshell->GetContentViewer(&contentv);
-            docshell->Release();
-            if (NS_SUCCEEDED(rv) && contentv) {
-                rv = contentv->QueryInterface(kIDocumentViewerIID, (void**) &docv);
-                contentv->Release();	
-                if (NS_SUCCEEDED(rv) && docv) {
-                    rv = docv->GetDocument(document);
-                    docv->Release();
-                    if (NS_SUCCEEDED(rv) && document) {
-                        rv = document->QueryInterface(kIDOMDocumentIID, (void**) &domDoc);
-                        if (NS_SUCCEEDED(rv) && docv) {
-                            return domDoc;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
-    fprintf(stderr, 
-            "=== GetDocument: failed: "
-            "container=%x, webshell=%x, contentViewer=%x, "
-            "documentViewer=%x, document=%x, "
-            "domDocument=%x, error=%x\n", 
-            (unsigned) (void*) container, 
-            (unsigned) (void*) docshell, 
-            (unsigned) (void*) contentv, 
-            (unsigned) (void*) docv, 
-            (unsigned) (void*) document, 
-            (unsigned) (void*) domDoc, 
-            rv);
-  return NULL;
-}

mozilla/java/dom/blackconnect/dom/accessor/bcDOMAccessor.jar.info

@@ -1,3 +0,0 @@
-6b777772-1dd2-11b2-91bd-d3ab05f89834
-bcDOMAccessor
-bcDOMAccessor

mozilla/java/dom/blackconnect/dom/accessor/bcDOMAccessor.java

@@ -1,56 +0,0 @@
-
-import org.mozilla.xpcom.*;
-import org.mozilla.dom.Attr;
-import org.mozilla.dom.Node;
-import org.mozilla.dom.Document;
-import org.mozilla.dom.Element;
-import org.mozilla.dom.DOMTreeDumper;
-
-
-public class bcDOMAccessor implements bcIDOMAccessor {
-    public bcDOMAccessor() {}
-    public Object queryInterface(IID iid) {
-        System.out.println("--[java]::queryInterface iid="+iid);
-        Object result;
-        if ( iid.equals(nsISupportsIID)
-             || iid.equals(bcIDOMAccessorIID)) {
-            result = this;
-        } else {
-            result = null;
-        }
-        System.out.println("--[java]::queryInterface result=null "+(result==null));
-        return result;
-    }
-  
-    public void endDocumentLoad(String url, Document doc) {
-	System.out.println("=== GOT URL: " + url);
-	if (url.startsWith("about")) {
-	    return;
-	}
-	new DOMTreeDumper().dumpToStream(System.out, doc);
-
-    }
-
-    static IID bcIDOMAccessorIID = new IID(bcIDOMAccessor.IID);
-    static IID nsISupportsIID = new IID(nsISupports.IID);
-    static {
-         InterfaceRegistry.register("org.mozilla.dom.Attr");
-         InterfaceRegistry.register("org.mozilla.dom.CDATASection");
-         InterfaceRegistry.register("org.mozilla.dom.CharacterData");
-         InterfaceRegistry.register("org.mozilla.dom.Comment");
-         InterfaceRegistry.register("org.mozilla.dom.Document");
-         InterfaceRegistry.register("org.mozilla.dom.DocumentFragment");
-         InterfaceRegistry.register("org.mozilla.dom.DocumentType");
-         InterfaceRegistry.register("org.mozilla.dom.DOMImplementation");
-         InterfaceRegistry.register("org.mozilla.dom.Element");
-         InterfaceRegistry.register("org.mozilla.dom.Entity");
-         InterfaceRegistry.register("org.mozilla.dom.EntityReference");
-         InterfaceRegistry.register("org.mozilla.dom.NamedNodeMap");
-         InterfaceRegistry.register("org.mozilla.dom.Node");
-         InterfaceRegistry.register("org.mozilla.dom.NodeList");
-         InterfaceRegistry.register("org.mozilla.dom.Notation");
-         InterfaceRegistry.register("org.mozilla.dom.ProcessingInstruction");
-         InterfaceRegistry.register("org.mozilla.dom.Text");    
-    }
-}
-

mozilla/java/dom/blackconnect/dom/accessor/bcIDOMAccessor.idl

@@ -1,9 +0,0 @@
-#include "nsISupports.idl"
-#include "dom.idl"
-
-#pragma prefix 
-[scriptable, uuid(d0ee9960-9ecf-11d4-a983-00105ae3801e)]
-interface bcIDOMAccessor : nsISupports
-{
-  void endDocumentLoad(in string url, in Document doc);
-};

mozilla/java/dom/blackconnect/dom/accessor/bcIDOMAccessor.java

@@ -1,30 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from bcIDOMAccessor.idl.
- */
-
-import org.mozilla.xpcom.*;
-import org.mozilla.dom.*;
-
-
-/**
- * Interface bcIDOMAccessor
- *
- * IID: 0xd0ee9960-9ecf-11d4-a983-00105ae3801e
- */
-
-public interface bcIDOMAccessor extends nsISupports
-{
-    public static final String IID =
-        "d0ee9960-9ecf-11d4-a983-00105ae3801e";
-
-
-    /* void endDocumentLoad (in string url, in Document doc); */
-    public void endDocumentLoad(String url, Document doc);
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/accessor/makefile.win

@@ -1,66 +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) 1999 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s):
-# Denis Sharypov <sdv@sparc.spb.su>
-#
-
-
-DEPTH		= ..\..\..\..\..
-topsrcdir	= ..\..\..\..\..
-srcdir		= .
-VPATH		= .
-
-MAKE_OBJ_TYPE=DLL
-MODULE=DOMAccessor
-COMPONENT=1
-DLLNAME=$(MODULE)
-DLL=.\$(OBJDIR)\$(DLLNAME).dll
-
-XPIDLSRCS	= \
-	.\bcIDOMAccessor.idl \
-	$(NULL)
-
-OBJS	= \
-	.\$(OBJDIR)\bcDOMAccessor.obj \
-	$(NULL)
-
-LLIBS=$(LLIBS) $(LIBNSPR) $(DIST)\lib\xpcom.lib $(DIST)\lib\javadomstubs.lib
-
-include <$(DEPTH)\config\rules.mak>
-
-bcDOMAccessor.jar.comp: manifest bcDOMAccessor.class bcDOMAccessor.class
-	$(JDKHOME)\bin\jar cvfm bcDOMAccessor.jar.comp  manifest *.class
-
-.SUFFIXES: .java .class
-
-.java.class:
-	$(JDKHOME)\bin\javac -classpath $(CLASSPATH) $<
-
-install-component: bcDOMAccessor.jar.comp bcDOMAccessor.jar.info $(DLL)
-	copy bcDOMAccessor.jar* $(DIST)\bin\components
-        copy $(DLL) $(DIST)\bin\components
-	
-clobber-java:
-	-del *.class *.jar.comp
-clobber:: clobber-java
-	rm $(DIST)\bin\components\$(DLLNAME).dll
-	rm $(DIST)\bin\components\bcDOMAccessor.jar.*
-clobber_all:: clobber-java
-install:: install-component

mozilla/java/dom/blackconnect/dom/accessor/manifest

@@ -1 +0,0 @@
-Component-Class: bcDOMAccessor

mozilla/java/dom/blackconnect/dom/classes/Makefile.in

@@ -1,40 +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 	\
-	$(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/blackconnect/dom/classes/makefile.win

@@ -1,35 +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 \
-	$(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/blackconnect/dom/classes/org/mozilla/dom/Attr.java

@@ -1,42 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface Attr
- *
- * IID: 0x09e31950-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Attr extends Node
-{
-    public static final String IID =
-        "09e31950-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DOMString name; */
-    public String getName();
-
-    /* readonly attribute boolean specified; */
-    public boolean getSpecified();
-
-    /* attribute DOMString value; */
-    public String getValue();
-    public void setValue(String value);
-
-    /* readonly attribute Element ownerElement; */
-    public Element getOwnerElement();
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/CDATASection.java

@@ -1,29 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface CDATASection
- *
- * IID: 0x0b813520-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface CDATASection extends Text
-{
-    public static final String IID =
-        "0b813520-9ad5-11d4-a983-00105ae3801e";
-
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/CharacterData.java

@@ -1,52 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-
-/**
- * Interface CharacterData
- *
- * IID: 0x0965cbf0-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface CharacterData extends Node
-{
-    public static final String IID =
-        "0965cbf0-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* attribute DOMString data; */
-    public String getData();
-    public void setData(String value);
-
-    /* readonly attribute unsigned long length; */
-    public int getLength();
-
-    /* DOMString substringData (in unsigned long offset, in unsigned long count)  raises (DOMException); */
-    public String substringData(int offset, int count) throws DOMException;
-
-    /* void appendData (in DOMString arg)  raises (DOMException); */
-    public void appendData(String arg) throws DOMException;
-
-    /* void insertData (in unsigned long offset, in DOMString arg)  raises (DOMException); */
-    public void insertData(int offset, String arg) throws DOMException;
-
-    /* void deleteData (in unsigned long offset, in unsigned long count)  raises (DOMException); */
-    public void deleteData(int offset, int count) throws DOMException;
-
-    /* void replaceData (in unsigned long offset, in unsigned long count, in DOMString arg)  raises (DOMException); */
-    public void replaceData(int offset, int count, String arg) throws DOMException;
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/Comment.java

@@ -1,29 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface Comment
- *
- * IID: 0x0ae9ed90-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Comment extends CharacterData
-{
-    public static final String IID =
-        "0ae9ed90-9ad5-11d4-a983-00105ae3801e";
-
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/DOMImplementation.java

@@ -1,39 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-
-/**
- * Interface DOMImplementation
- *
- * IID: 0x0776b330-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface DOMImplementation extends nsISupports
-{
-    public static final String IID =
-        "0776b330-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* boolean hasFeature (in DOMString feature, in DOMString version); */
-    public boolean hasFeature(String feature, String version);
-
-    /* DocumentType createDocumentType (in DOMString qualifiedName, in DOMString publicId, in DOMString systemId)  raises (DOMException); */
-    public DocumentType createDocumentType(String qualifiedName, String publicId, String systemId) throws DOMException;
-
-    /* Document createDocument (in DOMString namespaceURI, in DOMString qualifiedName, in DocumentType doctype)  raises (DOMException); */
-    public Document createDocument(String namespaceURI, String qualifiedName, DocumentType doctype) throws DOMException;
-
-}
-
-/*
- * end
- */

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

@@ -1,224 +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;
-
-import java.io.BufferedOutputStream;
-import java.io.PrintStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-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/blackconnect/dom/classes/org/mozilla/dom/Document.java

@@ -1,81 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-
-/**
- * Interface Document
- *
- * IID: 0x0e81d470-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Document extends Node
-{
-    public static final String IID =
-        "0e81d470-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DocumentType doctype; */
-    public DocumentType getDoctype();
-
-    /* readonly attribute DOMImplementation implementation; */
-    public DOMImplementation getImplementation();
-
-    /* readonly attribute Element documentElement; */
-    public Element getDocumentElement();
-
-    /* Element createElement (in DOMString tagName)  raises (DOMException); */
-    public Element createElement(String tagName) throws DOMException;
-
-    /* DocumentFragment createDocumentFragment (); */
-    public DocumentFragment createDocumentFragment();
-
-    /* Text createTextNode (in DOMString data); */
-    public Text createTextNode(String data);
-
-    /* Comment createComment (in DOMString data); */
-    public Comment createComment(String data);
-
-    /* CDATASection createCDATASection (in DOMString data)  raises (DOMException); */
-    public CDATASection createCDATASection(String data) throws DOMException;
-
-    /* ProcessingInstruction createProcessingInstruction (in DOMString target, in DOMString data)  raises (DOMException); */
-    public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException;
-
-    /* Attr createAttribute (in DOMString name)  raises (DOMException); */
-    public Attr createAttribute(String name) throws DOMException;
-
-    /* EntityReference createEntityReference (in DOMString name)  raises (DOMException); */
-    public EntityReference createEntityReference(String name) throws DOMException;
-
-    /* NodeList getElementsByTagName (in DOMString tagname); */
-    public NodeList getElementsByTagName(String tagname);
-
-    /* Node importNode (in Node importedNode, in boolean deep)  raises (DOMException); */
-    public Node importNode(Node importedNode, boolean deep) throws DOMException;
-
-    /* Element createElementNS (in DOMString namespaceURI, in DOMString qualifiedName)  raises (DOMException); */
-    public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException;
-
-    /* Attr createAttributeNS (in DOMString namespaceURI, in DOMString qualifiedName)  raises (DOMException); */
-    public Attr createAttributeNS(String namespaceURI, String qualifiedName) throws DOMException;
-
-    /* NodeList getElementsByTagNameNS (in DOMString namespaceURI, in DOMString localName); */
-    public NodeList getElementsByTagNameNS(String namespaceURI, String localName);
-
-    /* Element getElementById (in DOMString elementId); */
-    public Element getElementById(String elementId);
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/DocumentFragment.java

@@ -1,29 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface DocumentFragment
- *
- * IID: 0x0e249e00-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface DocumentFragment extends Node
-{
-    public static final String IID =
-        "0e249e00-9ad5-11d4-a983-00105ae3801e";
-
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/DocumentType.java

@@ -1,47 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface DocumentType
- *
- * IID: 0x0c07ada0-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface DocumentType extends Node
-{
-    public static final String IID =
-        "0c07ada0-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DOMString name; */
-    public String getName();
-
-    /* readonly attribute NamedNodeMap entities; */
-    public NamedNodeMap getEntities();
-
-    /* readonly attribute NamedNodeMap notations; */
-    public NamedNodeMap getNotations();
-
-    /* readonly attribute DOMString publicId; */
-    public String getPublicId();
-
-    /* readonly attribute DOMString systemId; */
-    public String getSystemId();
-
-    /* readonly attribute DOMString internalSubset; */
-    public String getInternalSubset();
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/Element.java

@@ -1,78 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-
-/**
- * Interface Element
- *
- * IID: 0x0a7d6f40-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Element extends Node
-{
-    public static final String IID =
-        "0a7d6f40-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DOMString tagName; */
-    public String getTagName();
-
-    /* DOMString getAttribute (in DOMString name); */
-    public String getAttribute(String name);
-
-    /* void setAttribute (in DOMString name, in DOMString value)  raises (DOMException); */
-    public void setAttribute(String name, String value) throws DOMException;
-
-    /* void removeAttribute (in DOMString name)  raises (DOMException); */
-    public void removeAttribute(String name) throws DOMException;
-
-    /* Attr getAttributeNode (in DOMString name); */
-    public Attr getAttributeNode(String name);
-
-    /* Attr setAttributeNode (in Attr newAttr)  raises (DOMException); */
-    public Attr setAttributeNode(Attr newAttr) throws DOMException;
-
-    /* Attr removeAttributeNode (in Attr oldAttr)  raises (DOMException); */
-    public Attr removeAttributeNode(Attr oldAttr) throws DOMException;
-
-    /* NodeList getElementsByTagName (in DOMString name); */
-    public NodeList getElementsByTagName(String name);
-
-    /* DOMString getAttributeNS (in DOMString namespaceURI, in DOMString localName); */
-    public String getAttributeNS(String namespaceURI, String localName);
-
-    /* void setAttributeNS (in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value)  raises (DOMException); */
-    public void setAttributeNS(String namespaceURI, String qualifiedName, String value) throws DOMException;
-
-    /* void removeAttributeNS (in DOMString namespaceURI, in DOMString localName)  raises (DOMException); */
-    public void removeAttributeNS(String namespaceURI, String localName) throws DOMException;
-
-    /* Attr getAttributeNodeNS (in DOMString namespaceURI, in DOMString localName); */
-    public Attr getAttributeNodeNS(String namespaceURI, String localName);
-
-    /* Attr setAttributeNodeNS (in Attr newAttr)  raises (DOMException); */
-    public Attr setAttributeNodeNS(Attr newAttr) throws DOMException;
-
-    /* NodeList getElementsByTagNameNS (in DOMString namespaceURI, in DOMString localName); */
-    public NodeList getElementsByTagNameNS(String namespaceURI, String localName);
-
-    /* boolean hasAttribute (in DOMString name); */
-    public boolean hasAttribute(String name);
-
-    /* boolean hasAttributeNS (in DOMString namespaceURI, in DOMString localName); */
-    public boolean hasAttributeNS(String namespaceURI, String localName);
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/Entity.java

@@ -1,38 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface Entity
- *
- * IID: 0x0cf30080-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Entity extends Node
-{
-    public static final String IID =
-        "0cf30080-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DOMString publicId; */
-    public String getPublicId();
-
-    /* readonly attribute DOMString systemId; */
-    public String getSystemId();
-
-    /* readonly attribute DOMString notationName; */
-    public String getNotationName();
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/EntityReference.java

@@ -1,29 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface EntityReference
- *
- * IID: 0x0d4eafc0-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface EntityReference extends Node
-{
-    public static final String IID =
-        "0d4eafc0-9ad5-11d4-a983-00105ae3801e";
-
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/NamedNodeMap.java

@@ -1,54 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-
-/**
- * Interface NamedNodeMap
- *
- * IID: 0x08f4b810-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface NamedNodeMap extends nsISupports
-{
-    public static final String IID =
-        "08f4b810-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* Node getNamedItem (in DOMString name); */
-    public Node getNamedItem(String name);
-
-    /* Node setNamedItem (in Node arg)  raises (DOMException); */
-    public Node setNamedItem(Node arg) throws DOMException;
-
-    /* Node removeNamedItem (in DOMString name)  raises (DOMException); */
-    public Node removeNamedItem(String name) throws DOMException;
-
-    /* Node item (in unsigned long index); */
-    public Node item(int index);
-
-    /* readonly attribute unsigned long length; */
-    public int getLength();
-
-    /* Node getNamedItemNS (in DOMString namespaceURI, in DOMString localName); */
-    public Node getNamedItemNS(String namespaceURI, String localName);
-
-    /* Node setNamedItemNS (in Node arg)  raises (DOMException); */
-    public Node setNamedItemNS(Node arg) throws DOMException;
-
-    /* Node removeNamedItemNS (in DOMString namespaceURI, in DOMString localName)  raises (DOMException); */
-    public Node removeNamedItemNS(String namespaceURI, String localName) throws DOMException;
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/Node.java

@@ -1,133 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-/**
- * Interface Node
- *
- * IID: 0x082f98e0-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Node extends nsISupports
-{
-    public static final String IID =
-        "082f98e0-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* const unsigned short ELEMENT_NODE = 1; */
-    public static final short ELEMENT_NODE = 1;
-
-    /* const unsigned short ATTRIBUTE_NODE = 2; */
-    public static final short ATTRIBUTE_NODE = 2;
-
-    /* const unsigned short TEXT_NODE = 3; */
-    public static final short TEXT_NODE = 3;
-
-    /* const unsigned short CDATA_SECTION_NODE = 4; */
-    public static final short CDATA_SECTION_NODE = 4;
-
-    /* const unsigned short ENTITY_REFERENCE_NODE = 5; */
-    public static final short ENTITY_REFERENCE_NODE = 5;
-
-    /* const unsigned short ENTITY_NODE = 6; */
-    public static final short ENTITY_NODE = 6;
-
-    /* const unsigned short PROCESSING_INSTRUCTION_NODE = 7; */
-    public static final short PROCESSING_INSTRUCTION_NODE = 7;
-
-    /* const unsigned short COMMENT_NODE = 8; */
-    public static final short COMMENT_NODE = 8;
-
-    /* const unsigned short DOCUMENT_NODE = 9; */
-    public static final short DOCUMENT_NODE = 9;
-
-    /* const unsigned short DOCUMENT_TYPE_NODE = 10; */
-    public static final short DOCUMENT_TYPE_NODE = 10;
-
-    /* const unsigned short DOCUMENT_FRAGMENT_NODE = 11; */
-    public static final short DOCUMENT_FRAGMENT_NODE = 11;
-
-    /* const unsigned short NOTATION_NODE = 12; */
-    public static final short NOTATION_NODE = 12;
-
-    /* readonly attribute DOMString nodeName; */
-    public String getNodeName();
-
-    /* attribute DOMString nodeValue; */
-    public String getNodeValue();
-    public void setNodeValue(String value);
-
-    /* readonly attribute unsigned short nodeType; */
-    public short getNodeType();
-
-    /* readonly attribute Node parentNode; */
-    public Node getParentNode();
-
-    /* readonly attribute NodeList childNodes; */
-    public NodeList getChildNodes();
-
-    /* readonly attribute Node firstChild; */
-    public Node getFirstChild();
-
-    /* readonly attribute Node lastChild; */
-    public Node getLastChild();
-
-    /* readonly attribute Node previousSibling; */
-    public Node getPreviousSibling();
-
-    /* readonly attribute Node nextSibling; */
-    public Node getNextSibling();
-
-    /* readonly attribute NamedNodeMap attributes; */
-    public NamedNodeMap getAttributes();
-
-    /* readonly attribute Document ownerDocument; */
-    public Document getOwnerDocument();
-
-    /* Node insertBefore (in Node newChild, in Node refChild)  raises (DOMException); */
-    public Node insertBefore(Node newChild, Node refChild) throws DOMException;
-
-    /* Node replaceChild (in Node newChild, in Node oldChild)  raises (DOMException); */
-    public Node replaceChild(Node newChild, Node oldChild) throws DOMException;
-
-    /* Node removeChild (in Node oldChild)  raises (DOMException); */
-    public Node removeChild(Node oldChild) throws DOMException;
-
-    /* Node appendChild (in Node newChild)  raises (DOMException); */
-    public Node appendChild(Node newChild) throws DOMException;
-
-    /* boolean hasChildNodes (); */
-    public boolean hasChildNodes();
-
-    /* Node cloneNode (in boolean deep); */
-    public Node cloneNode(boolean deep);
-
-    /* void normalize (); */
-    public void normalize();
-
-    /* boolean supports (in DOMString feature, in DOMString version); */
-    public boolean supports(String feature, String version);
-
-    /* readonly attribute DOMString namespaceURI; */
-    public String getNamespaceURI();
-
-    /* attribute DOMString prefix; */
-    public String getPrefix();
-    public void setPrefix(String value);
-
-    /* readonly attribute DOMString localName; */
-    public String getLocalName();
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/NodeList.java

@@ -1,35 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface NodeList
- *
- * IID: 0x0895fa70-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface NodeList extends nsISupports
-{
-    public static final String IID =
-        "0895fa70-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* Node item (in unsigned long index); */
-    public Node item(int index);
-
-    /* readonly attribute unsigned long length; */
-    public int getLength();
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/Notation.java

@@ -1,35 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface Notation
- *
- * IID: 0x0c7a48b0-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Notation extends Node
-{
-    public static final String IID =
-        "0c7a48b0-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DOMString publicId; */
-    public String getPublicId();
-
-    /* readonly attribute DOMString systemId; */
-    public String getSystemId();
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/ProcessingInstruction.java

@@ -1,36 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-
-
-/**
- * Interface ProcessingInstruction
- *
- * IID: 0x0db69880-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface ProcessingInstruction extends Node
-{
-    public static final String IID =
-        "0db69880-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* readonly attribute DOMString target; */
-    public String getTarget();
-
-    /* attribute DOMString data; */
-    public String getData();
-    public void setData(String value);
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/Text.java

@@ -1,33 +0,0 @@
-/*
- * ************* DO NOT EDIT THIS FILE ***********
- *
- * This file was automatically generated from dom.idl.
- */
-
-
-package org.mozilla.dom;
-
-import org.mozilla.xpcom.*;
-import org.w3c.dom.DOMException;
-
-
-/**
- * Interface Text
- *
- * IID: 0x0eefd9f0-9ad5-11d4-a983-00105ae3801e
- */
-
-public interface Text extends CharacterData
-{
-    public static final String IID =
-        "0eefd9f0-9ad5-11d4-a983-00105ae3801e";
-
-
-    /* Text splitText (in unsigned long offset)  raises (DOMException); */
-    public Text splitText(int offset) throws DOMException;
-
-}
-
-/*
- * end
- */

mozilla/java/dom/blackconnect/dom/classes/org/mozilla/dom/doit.bat

@@ -1 +0,0 @@
-C:\jdk1.3\bin\javac -classpath .;C:\JDK1.3\jre\lib\rt.jar;;C:\JDK1.3\jre\lib\jaws.jar;d:\wrk\mozilla\dist\classes;;d:\wrk\classes;;d:\wrk\mozilla\dist\classes -d d:\wrk\mozilla\dist\classes Attr.java CDATASection.java CharacterData.java Comment.java Document.java DocumentFragment.java DocumentType.java DOMImplementation.java DOMTreeDumper.java Element.java Entity.java EntityReference.java NamedNodeMap.java Node.java NodeList.java Notation.java ProcessingInstruction.java Text.java 

mozilla/java/dom/blackconnect/dom/makefile.win

@@ -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): 
-
-IGNORE_MANIFEST=1 
-#//------------------------------------------------------------------------
-#//
-#// Specify the depth of the current directory relative to the
-#// root of NS
-#//
-#//------------------------------------------------------------------------
-DEPTH = ..\..\..\..
-
-DIRS  = classes stubs accessor
-
-include <$(DEPTH)\config\rules.mak>

mozilla/java/dom/blackconnect/dom/readme

@@ -1,88 +0,0 @@
-About the project
-=================
-
-The goal is to provide access to the DOM API provided
-by the mozilla browser using the java to xpcom bridge(Blackconnect).
-
-The implementation currently consists of stubs between mozilla core DOM 
-interfaces and  core DOM interfaces defined in dom.idl (blackconnect
-requires scriptable interfaces), java interfaces generated from
-dom.idl and a DOMAccessor as an example of using the DOM API.
-
-
-Sources
-=======
-
-The sources are located in mozilla/java/dom
-Subdirectories 
-
-   classes  - contains classes generated automatically from
-              idl definition of core DOM interfaces (stubs/dom.idl)             
-              using xpidl compiler (mozilla/java/xpcom/java/xpidl)
-              and a sample DOMTreeDumper class that dumps an html
-              document source using its DOM tree.
-
-   stubs    - stubs between mozilla core DOM interfaces and 
-              core DOM interfaces defined in dom.idl
-
-   accessor - a sample java component which demonstrates the
-              use of the DOM API from java via blackconnect
-
-
-Building
-========
-   Requirenments:
-   --------------
-   - you need to build the blackconnect bridge
-     mozilla/java/xpcom and to have all the
-     environment variables set required for
-     building blackconnect
-   - mozilla_Netscape_20000922_BRANCH mozilla build
-   - JDK1.3 
-   - Perl 5 must be in your path
-   - JDKHOME environment variable set to your JDK dir
-   - CLASSPATH environment variable set to contain 
-     mozilla/dist/classes directory and 
-	 org.w3c.dom.DOMException class. The source can be found at	
-     http://www.w3.org/TR/2000/CR-DOM-Level-2-20000510/java-binding.html
-
-   Solaris and Linux:
-   ------------------
-   goto mozilla/java/dom directory and type "gmake"
-
-   Windows NT:
-   -----------
-   goto mozilla/java/dom directory and type "nmake /f makefile.win"
-
-
-Running
-=======
-   After building a component run a mozilla browser. The document
-   sources will be dumped into console.
-
-Using the Java DOM API
-======================
-   
-   Directory accessor contains a sample java component which
-   becomes a document load listener and dumps sources of documents 
-   being displayed in mozilla using their DOM trees.
-
-   if you have a C++ pointer to any core DOM mozilla interface nsIDOM<...>
-   you need to wrap it into a corresponding scriptable stub interface
-   bc<...> (e.g. nsIDOMDocument into bcDocument using 
-   bcDocument::bcDocument(nsIDOMDocument* ptr) constructor) and you
-   can use it to pass to java as a class instance which implements 
-   a org.mozill.dom.Document interface using blackconnect.
-
-   An example works this way: 
-   A C++ implementation of a component gets a call via NSGetModule method, 
-   registrates itself as a document load listener, gets a reference to
-   a java component and then pass references to all documents being 
-   displayed into a java component.
-
-Notes:
-   - Since exception passing mechanism is not yet implemented in blackconnect
-     no DOMExceptions are raised.
-    
-   - The mechanism used in a sample allows to modify any documents in any
-     way provided by the DOM API, so there are no security restrictions at all.

mozilla/java/dom/blackconnect/dom/stubs/Makefile.in

@@ -1,74 +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
-
-LIBRARY_NAME    = javadomstubs
-MODULE		= javadomstubs
-XPIDLSRCS	= dom.idl 
-
-CPPSRCS       = bcNode.cpp \
-		bcElement.cpp \
-		bcAttr.cpp \
-		bcNodeList.cpp \
-		bcNamedNodeMap.cpp \
-		bcDocument.cpp \
-		bcCharacterData.cpp \
-		bcText.cpp \
-		bcComment.cpp \
-		bcCDATASection.cpp \
-		bcDocumentFragment.cpp \
-		bcEntityReference.cpp \
-		bcEntity.cpp \
-		bcNotation.cpp \
-		bcDocumentType.cpp \
-		bcProcessingInstruction.cpp \
-		bcDOMImplementation.cpp \
-		$(NULL)
-
-EXPORTS       = bcNode.h \
-		bcElement.h \
-		bcAttr.h \
-		bcNodeList.h \
-		bcNamedNodeMap.h \
-		bcDocument.h \
-		bcCharacterData.h \
-		bcText.h \
-		bcComment.h \
-		bcCDATASection.h \
-		bcDocumentFragment.h \
-		bcEntityReference.h \
-		bcEntity.h \
-		bcNotation.h \
-		bcDocumentType.h \
-		bcProcessingInstruction.h \
-		bcDOMImplementation.h \
-		$(NULL)
-
-
-include $(topsrcdir)/config/rules.mk